public MutationTest()
{
ILoggerFactory factory = new NullLoggerFactory();
_projectService = new ProjectService(_context);
_evaluationService = new EvaluationService(_context);
_participantService = new ParticipantService(_context);
_questionService = new QuestionService(_context);
_answerService = new AnswerService(_context);
_questionTemplateService = new QuestionTemplateService(_context);
_actionService = new ActionService(_context);
_noteService = new NoteService(_context);
_mutation = new Mutation(
_projectService,
_evaluationService,
_participantService,
_questionService,
_answerService,
_questionTemplateService,
_actionService,
_noteService,
new MockAuthService(),
new Logger <Mutation>(factory)
);
}
public void CreateFollowUpAnswers()
{
ParticipantService participantService = new ParticipantService(fixture.context);
QuestionService questionService = new QuestionService(fixture.context);
AnswerService answerService = new AnswerService(fixture.context);
ProjectService projectService = new ProjectService(fixture.context);
Project project = projectService.Create("AnswerService_GetFromQuestionExists");
EvaluationService evaluationService = new EvaluationService(fixture.context);
Evaluation evaluation = evaluationService.Create("AnswerService_GetFromQuestionExists", project, "");
Participant participant = participantService.Create("CreateFollowUpAnswers_id", evaluation, Organization.All, Role.Facilitator);
QuestionTemplateService qts = new QuestionTemplateService(fixture.context);
List <Question> questions = questionService.CreateBulk(qts.GetAll().ToList(), evaluation);
answerService.Create(participant, questions[0], Severity.High, "test_answer_0", Progression.Workshop);
answerService.Create(participant, questions[1], Severity.High, "test_answer_1", Progression.Workshop);
answerService.Create(participant, questions[2], Severity.High, "test_answer_2", Progression.Workshop);
int nAnswersFollowupBefore = answerService.GetAll().Where(a => (a.Progression.Equals(Progression.FollowUp) && a.Question.Evaluation.Equals(evaluation))).Count();
int nAnswersWorkshop = answerService.GetAll().Where(a => (a.Progression.Equals(Progression.Workshop) && a.Question.Evaluation.Equals(evaluation))).Count();
answerService.CreateFollowUpAnswers(evaluation);
int nAnswersFollowup = answerService.GetAll().Where(a => (a.Progression.Equals(Progression.FollowUp) && a.Question.Evaluation.Equals(evaluation))).Count();
Assert.Equal(nAnswersFollowupBefore + nAnswersWorkshop, nAnswersFollowup);
}
public void CopyUsingCreate()
{
var service = new QuestionTemplateService(fixture.context);
var questionTemplateToCopy = service.Create(
barrier: Randomize.Barrier(),
organization: Randomize.Organization(),
text: Randomize.String(),
supportNotes: Randomize.String()
);
int maxAdminOrder = service.GetAll()
.Where(qt => qt.Status == Status.Active)
.Max(qt => qt.AdminOrder)
;
var newQuestionTemplate = service.Create(
barrier: questionTemplateToCopy.Barrier,
organization: questionTemplateToCopy.Organization,
text: questionTemplateToCopy.Text,
supportNotes: questionTemplateToCopy.SupportNotes,
newOrder: questionTemplateToCopy.Order + 1
);
Assert.Equal(questionTemplateToCopy.Order + 1, newQuestionTemplate.Order);
Assert.Equal(maxAdminOrder + 1, newQuestionTemplate.AdminOrder);
}
public void Create()
{
QuestionTemplateService questionTemplateService = new QuestionTemplateService(fixture.context);
Barrier barrier = Randomize.Barrier();
int maxBarrierOrder = questionTemplateService.GetAll()
.Where(qt => qt.Status == Status.Active)
.Where(qt => qt.Barrier == barrier)
.Max(qt => qt.Order)
;
int maxAdminOrder = questionTemplateService.GetAll()
.Where(qt => qt.Status == Status.Active)
.Max(qt => qt.AdminOrder)
;
int nQuestionTemplatesBefore = questionTemplateService.GetAll().Count();
int maxOrderBefore = questionTemplateService.GetAll().Where(qt => qt.Status == Status.Active).Max(qt => qt.Order);
var newQuestionTemplate = questionTemplateService.Create(barrier, Organization.All, "text", "supportNotes");
int nQuestionTemplatesAfter = questionTemplateService.GetAll().Count();
int maxOrderAfter = questionTemplateService.GetAll().Where(qt => qt.Status == Status.Active).Max(qt => qt.Order);
Assert.Equal(nQuestionTemplatesBefore + 1, nQuestionTemplatesAfter);
Assert.Equal(maxBarrierOrder + 1, newQuestionTemplate.Order);
Assert.Equal(maxOrderBefore + 1, maxOrderAfter);
Assert.Equal(maxAdminOrder + 1, newQuestionTemplate.AdminOrder);
}
public void RemoveFromSeveralProjectCategories()
{
var projectCategoryService = new ProjectCategoryService(fixture.context);
var projectCategory1 = projectCategoryService.Create(Randomize.String());
var projectCategory2 = projectCategoryService.Create(Randomize.String());
var projectCategoryIds = new List <string> {
projectCategory1.Id, projectCategory2.Id
};
var service = new QuestionTemplateService(fixture.context);
var template = service.GetAll().First();
service.AddToProjectCategory(template.Id, projectCategory1.Id);
service.AddToProjectCategory(template.Id, projectCategory2.Id);
var nActiveFirstCategory = service.ActiveQuestions(projectCategory1).Count();
var nActiveSecondCategory = service.ActiveQuestions(projectCategory2).Count();
var nTemplates = service.GetAll().Count();
var updatedQT = service.RemoveFromProjectCategories(template.Id, projectCategoryIds);
var updatedPC1 = projectCategoryService.Get(projectCategory1.Id);
var updatedPC2 = projectCategoryService.Get(projectCategory2.Id);
Assert.False(updatedQT.ProjectCategories.Contains(updatedPC1));
Assert.False(updatedQT.ProjectCategories.Contains(updatedPC2));
Assert.False(updatedPC1.QuestionTemplates.Contains(updatedQT));
Assert.False(updatedPC2.QuestionTemplates.Contains(updatedQT));
Assert.Equal(nActiveFirstCategory - 1, service.ActiveQuestions(projectCategory1).Count());
Assert.Equal(nActiveSecondCategory - 1, service.ActiveQuestions(projectCategory2).Count());
Assert.Equal(nTemplates, service.GetAll().Count());
}
public Mutation(
ProjectService projectService,
EvaluationService evaluationService,
ParticipantService participantService,
QuestionService questionService,
AnswerService answerService,
ActionService actionService,
NoteService noteService,
ClosingRemarkService closingRemarkService,
QuestionTemplateService questionTemplateService,
ProjectCategoryService projectCategoryService,
IAuthService authService,
ILogger <Mutation> logger
)
{
_projectService = projectService;
_evaluationService = evaluationService;
_participantService = participantService;
_questionService = questionService;
_answerService = answerService;
_actionService = actionService;
_noteService = noteService;
_closingRemarkService = closingRemarkService;
_questionTemplateService = questionTemplateService;
_projectCategoryService = projectCategoryService;
_authService = authService;
_logger = logger;
}
public void RemoveFromProjectCategory()
{
var projectCategoryService = new ProjectCategoryService(fixture.context);
var projectCategory = projectCategoryService.Create(Randomize.String());
var service = new QuestionTemplateService(fixture.context);
var template = service.GetAll().First();
service.AddToProjectCategory(template.Id, projectCategory.Id);
var nActive = service.ActiveQuestions(projectCategory).Count();
var nTemplates = service.GetAll().Count();
var updatedQT = service.RemoveFromProjectCategories(template.Id, new List <string> {
projectCategory.Id
});
var updatedPC = projectCategoryService.Get(projectCategory.Id);
Assert.False(updatedQT.ProjectCategories.Contains(updatedPC));
Assert.False(updatedPC.QuestionTemplates.Contains(updatedQT));
Assert.Equal(nActive - 1, service.ActiveQuestions(projectCategory).Count());
Assert.Equal(nTemplates, service.GetAll().Count());
/* Removing the same QuestionTemplate should fail */
Assert.Throws <Exception>(() =>
service.RemoveFromProjectCategories(template.Id, new List <string> {
projectCategory.Id
})
);
}
public MutationTest(DatabaseFixture fixture)
{
this.fixture = fixture;
ILoggerFactory factory = new NullLoggerFactory();
_projectService = new ProjectService(fixture.context);
_evaluationService = new EvaluationService(fixture.context);
_participantService = new ParticipantService(fixture.context);
_questionService = new QuestionService(fixture.context);
_answerService = new AnswerService(fixture.context);
_actionService = new ActionService(fixture.context);
_noteService = new NoteService(fixture.context);
_closingRemarkService = new ClosingRemarkService(fixture.context);
_questionTemplateService = new QuestionTemplateService(fixture.context);
_projectCategoryService = new ProjectCategoryService(fixture.context);
_authService = new MockAuthService();
_mutation = new Mutation(
_projectService,
_evaluationService,
_participantService,
_questionService,
_answerService,
_actionService,
_noteService,
_closingRemarkService,
_questionTemplateService,
_projectCategoryService,
_authService,
new Logger <Mutation>(factory)
);
_project = _projectService.Create("Project");
}
public void GetQueryable()
{
QuestionTemplateService questionTemplateService = new QuestionTemplateService(_context);
IQueryable <QuestionTemplate> questions = questionTemplateService.GetAll();
Assert.True(questions.Count() > 0);
}
public void GetExists()
{
QuestionTemplateService questionTemplateService = new QuestionTemplateService(_context);
QuestionTemplate questionTemplateCreate = questionTemplateService.Create(Barrier.GM, Organization.All, "text", "supportNotes");
QuestionTemplate questionTemplateGet = questionTemplateService.GetQuestionTemplate(questionTemplateCreate.Id);
Assert.Equal(questionTemplateCreate, questionTemplateGet);
}
public void ReorderQuestionTemplateToLast()
{
QuestionTemplateService questionTemplateService = new QuestionTemplateService(_context);
IQueryable <QuestionTemplate> getAll = questionTemplateService.GetAll();
QuestionTemplate questionTemplate = getAll.ToList()[3];
int newOrder = _context.QuestionTemplates.Max(qt => qt.Order);
QuestionTemplate resultingQuestionTemplate = questionTemplateService.ReorderQuestionTemplate(questionTemplate);
Assert.Equal(newOrder, resultingQuestionTemplate.Order);
}
public void DeleteQuestionTemplate()
{
var service = new QuestionTemplateService(fixture.context);
Barrier barrier = Randomize.Barrier();
var questionTemplateToDelete = service.Create(
barrier: barrier,
organization: Randomize.Organization(),
text: Randomize.String(),
supportNotes: Randomize.String()
);
var projectCategory = new ProjectCategoryService(fixture.context).GetAll().First();
questionTemplateToDelete = service.AddToProjectCategory(questionTemplateToDelete.Id, projectCategory.Id);
int maxOrderActive = service.GetAll()
.Where(qt => qt.Status == Status.Active)
.Max(qt => qt.Order)
;
int maxBarrierOrder = service.GetAll()
.Where(qt => qt.Status == Status.Active)
.Where(qt => qt.Barrier == barrier)
.Max(qt => qt.Order)
;
int maxAdminOrder = service.GetAll()
.Where(qt => qt.Status == Status.Active)
.Max(qt => qt.AdminOrder)
;
var deletedQuestionTemplate = service.Delete(questionTemplateToDelete);
int maxOrderActiveAfter = service.GetAll()
.Where(qt => qt.Status == Status.Active)
.Max(qt => qt.Order)
;
int maxBarrierOrderAfter = service.GetAll()
.Where(qt => qt.Status == Status.Active)
.Where(qt => qt.Barrier == barrier)
.Max(qt => qt.Order)
;
int maxAdminOrderAfter = service.GetAll()
.Where(qt => qt.Status == Status.Active)
.Max(qt => qt.AdminOrder)
;
int maxOrder = fixture.context.QuestionTemplates.Max(qt => qt.Order);
Assert.Equal(maxOrderActive - 1, maxOrderActiveAfter);
Assert.Equal(maxBarrierOrder - 1, maxBarrierOrderAfter);
Assert.Equal(maxAdminOrder - 1, maxAdminOrderAfter);
Assert.Equal(deletedQuestionTemplate.Order, maxOrder);
Assert.True(deletedQuestionTemplate.Status == Status.Voided);
Assert.Equal(deletedQuestionTemplate.ProjectCategories, questionTemplateToDelete.ProjectCategories);
}
public void Create()
{
QuestionTemplateService questionTemplateService = new QuestionTemplateService(_context);
int nQuestionTemplatesBefore = questionTemplateService.GetAll().Count();
questionTemplateService.Create(Barrier.GM, Organization.All, "text", "supportNotes");
int nQuestionTemplatesAfter = questionTemplateService.GetAll().Count();
Assert.Equal(nQuestionTemplatesBefore + 1, nQuestionTemplatesAfter);
}
public void ActiveQuestions()
{
QuestionTemplateService questionTemplateService = new QuestionTemplateService(_context);
List <QuestionTemplate> questionTemplates = questionTemplateService.ActiveQuestions();
Assert.Equal(15, questionTemplates.Count);
foreach (QuestionTemplate qt in questionTemplates)
{
Assert.True(qt.Status.Equals(Status.Active));
}
}
public void ReorderQuestionTemplate()
{
QuestionTemplateService questionTemplateService = new QuestionTemplateService(_context);
IQueryable <QuestionTemplate> getAll = questionTemplateService.GetAll();
QuestionTemplate questionTemplate = getAll.ToList()[3];
QuestionTemplate newNextQuestionTemplate = getAll.ToList()[10];
int newOrder = newNextQuestionTemplate.Order;
QuestionTemplate resultingQuestionTemplate = questionTemplateService.ReorderQuestionTemplate(questionTemplate, newNextQuestionTemplate);
Assert.Equal(newOrder - 1, resultingQuestionTemplate.Order);
}
public void EditQuestionTemplate()
{
QuestionTemplateService questionTemplateService = new QuestionTemplateService(_context);
string initialText = "initial text";
QuestionTemplate questionTemplate = questionTemplateService.Create(Barrier.GM, Organization.All, initialText, "supportNotes");
string newtext = "new text";
Barrier newBarrier = Barrier.PS1;
QuestionTemplate resultingQuestionTemplate = questionTemplateService.Edit(questionTemplate, newBarrier, Organization.Commissioning, newtext, "supportNotes", Status.Active);
Assert.Equal(newtext, resultingQuestionTemplate.Text);
Assert.Equal(newBarrier, resultingQuestionTemplate.Barrier);
Assert.Equal(questionTemplate, resultingQuestionTemplate.previous);
}
public void GetExists()
{
QuestionTemplateService questionTemplateService = new QuestionTemplateService(_context);
QuestionTemplate questionTemplate = questionTemplateService.GetAll().First();
EvaluationService evaluationService = new EvaluationService(_context);
Evaluation evaluation = evaluationService.GetAll().First();
QuestionService questionService = new QuestionService(_context);
Question questionCreate = questionService.Create(questionTemplate, evaluation);
Question questionGet = questionService.GetQuestion(questionCreate.Id).First();
Assert.Equal(questionCreate, questionGet);
}
public void GetExists()
{
QuestionTemplateService questionTemplateService = new QuestionTemplateService(fixture.context);
QuestionTemplate questionTemplate = questionTemplateService.GetAll().First();
ProjectService projectService = new ProjectService(fixture.context);
Project project = projectService.Create("QuestionService_GetExists");
EvaluationService evaluationService = new EvaluationService(fixture.context);
Evaluation evaluation = evaluationService.Create("QuestionService_GetExists", project, "");
QuestionService questionService = new QuestionService(fixture.context);
Question questionCreate = questionService.Create(questionTemplate, evaluation);
Question questionGet = questionService.GetQuestion(questionCreate.Id).First();
Assert.Equal(questionCreate, questionGet);
}
public void ReorderQuestionTemplateToLast()
{
QuestionTemplateService questionTemplateService = new QuestionTemplateService(fixture.context);
IQueryable <QuestionTemplate> getAll = questionTemplateService.GetAll();
QuestionTemplate questionTemplate = getAll
.Where(qt => qt.Status == Status.Active)
.First(qt => qt.Order == 2)
;
int newOrder = getAll
.Where(qt => qt.Status == Status.Active)
.Max(qt => qt.Order)
;
QuestionTemplate resultingQuestionTemplate = questionTemplateService.ReorderQuestionTemplate(questionTemplate);
Assert.Equal(newOrder, resultingQuestionTemplate.Order);
}
public void CreateBulk()
{
QuestionTemplateService questionTemplateService = new QuestionTemplateService(_context);
List <QuestionTemplate> questionTemplates = questionTemplateService.GetAll().ToList();
EvaluationService evaluationService = new EvaluationService(_context);
Evaluation evaluation = evaluationService.GetAll().First();
QuestionService questionService = new QuestionService(_context);
int nQuestionBefore = questionService.GetAll().Count();
questionService.CreateBulk(questionTemplates, evaluation);
int nQuestionsAfter = questionService.GetAll().Count();
Assert.Equal(nQuestionBefore + 11, nQuestionsAfter);
}
public Mutation(
ProjectService projectService,
EvaluationService evaluationService,
ParticipantService participantService,
QuestionService questionService,
AnswerService answerService,
QuestionTemplateService questionTemplateService,
IAuthService authService
)
{
_projectService = projectService;
_evaluationService = evaluationService;
_participantService = participantService;
_questionService = questionService;
_answerService = answerService;
_questionTemplateService = questionTemplateService;
_authService = authService;
}
public void EditQuestionTemplate()
{
var service = new QuestionTemplateService(fixture.context);
Barrier barrier = Randomize.Barrier();
var originalQT = service.Create(
barrier: barrier,
organization: Randomize.Organization(),
text: Randomize.String(),
supportNotes: Randomize.String()
);
var projectCategory = new ProjectCategoryService(fixture.context).GetAll().First();
originalQT = service.AddToProjectCategory(originalQT.Id, projectCategory.Id);
var nTemplates = service.GetAll().Count();
var nActive = service.ActiveQuestions(projectCategory).Count();
var newText = Randomize.String();
var newSupportNotes = Randomize.String();
var newOrganization = Randomize.Organization();
var updatedQT = service.Edit(
questionTemplate: originalQT,
barrier: barrier,
organization: newOrganization,
text: newText,
supportNotes: newSupportNotes,
status: Status.Active
);
Assert.Equal(nTemplates + 1, service.GetAll().Count());
Assert.Equal(nActive, service.ActiveQuestions(projectCategory).Count());
Assert.Equal(newText, updatedQT.Text);
Assert.Equal(newSupportNotes, updatedQT.SupportNotes);
Assert.Equal(barrier, updatedQT.Barrier);
Assert.Equal(newOrganization, updatedQT.Organization);
Assert.Equal(originalQT, updatedQT.previous);
Assert.True(updatedQT.ProjectCategories.Count() == 1);
Assert.Equal(updatedQT.AdminOrder, originalQT.AdminOrder);
}
public void Create()
{
QuestionTemplateService questionTemplateService = new QuestionTemplateService(_context);
QuestionTemplate questionTemplate = questionTemplateService.GetAll().First();
ProjectService projectService = new ProjectService(_context);
Project project = projectService.Create("QuestionService_Create");
EvaluationService evaluationService = new EvaluationService(_context);
Evaluation evaluation = evaluationService.Create("QuestionService_Create", project);
QuestionService questionService = new QuestionService(_context);
int nQuestionBefore = questionService.GetAll().Count();
questionService.Create(questionTemplate, evaluation);
int nQuestionsAfter = questionService.GetAll().Count();
Assert.Equal(nQuestionBefore + 1, nQuestionsAfter);
}
public void CreateBulk()
{
QuestionTemplateService questionTemplateService = new QuestionTemplateService(fixture.context);
List <QuestionTemplate> questionTemplates = questionTemplateService.GetAll().ToList();
ProjectService projectService = new ProjectService(fixture.context);
Project project = projectService.Create("QuestionService_CreateBulk");
EvaluationService evaluationService = new EvaluationService(fixture.context);
Evaluation evaluation = evaluationService.Create("QuestionService_CreateBulk", project, "");
QuestionService questionService = new QuestionService(fixture.context);
int nQuestionBefore = questionService.GetAll().Count();
questionService.CreateBulk(questionTemplates, evaluation);
int nQuestionsAfter = questionService.GetAll().Count();
Assert.Equal(nQuestionBefore + 15, nQuestionsAfter);
}
public void Delete()
{
var service = new ProjectCategoryService(fixture.context);
int nCategories = service.GetAll().Count();
var oldProjectCategory = service.GetAll().First();
var newProjectCategory = service.CopyFrom(Randomize.String(), oldProjectCategory);
var qtService = new QuestionTemplateService(fixture.context);
var questionTemplate = qtService
.GetAll()
.Include(x => x.ProjectCategories)
.First(x => x.ProjectCategories.Contains(newProjectCategory))
;
service.Delete(newProjectCategory);
questionTemplate = qtService.GetQuestionTemplate(questionTemplate.Id);
Assert.False(questionTemplate.ProjectCategories.Contains(newProjectCategory));
Assert.Equal(nCategories, service.GetAll().Count());
}
public void GetFromQuestionExists()
{
QuestionTemplateService questionTemplateService = new QuestionTemplateService(_context);
QuestionTemplate questionTemplate = questionTemplateService.GetAll().First();
EvaluationService evaluationService = new EvaluationService(_context);
Evaluation evaluation = evaluationService.GetAll().First();
ParticipantService participantService = new ParticipantService(_context);
Participant participant = participantService.GetAll().ToList()[0];
QuestionService questionService = new QuestionService(_context);
Question question = questionService.Create(questionTemplate, evaluation);
AnswerService answerService = new AnswerService(_context);
Answer answerCreate = answerService.Create(participant, question, Severity.High, "test_answer");
Answer answerGet = answerService.GetAnswer(question, participant, question.Evaluation.Progression);
Assert.Equal(answerCreate, answerGet);
}
public void DoNotReorderInactiveQuestionTemplate()
{
QuestionTemplateService questionTemplateService = new QuestionTemplateService(fixture.context);
IQueryable <QuestionTemplate> getAll = questionTemplateService.GetAll();
// Edit a question template to make sure an inactive question template exists
var originalQT = getAll.First();
var updatedQT = questionTemplateService.Edit(
questionTemplate: originalQT,
barrier: originalQT.Barrier,
organization: Randomize.Organization(),
text: Randomize.String(),
supportNotes: Randomize.String(),
status: Status.Active
);
var inactiveQuestionTemplate = getAll
.Where(qt => qt.Status == Status.Inactive)
.First()
;
QuestionTemplate resultingQuestionTemplate = questionTemplateService.ReorderQuestionTemplate(inactiveQuestionTemplate);
Assert.Equal(inactiveQuestionTemplate.Order, resultingQuestionTemplate.Order);
}
public void AddToProjectCategory()
{
var projectCategoryService = new ProjectCategoryService(fixture.context);
var projectCategory = projectCategoryService.Create(Randomize.String());
var service = new QuestionTemplateService(fixture.context);
var nActive = service.ActiveQuestions(projectCategory).Count();
var nTemplates = service.GetAll().Count();
var template = service.GetAll().First();
var updatedQT = service.AddToProjectCategory(template.Id, projectCategory.Id);
var updatedSP = projectCategoryService.Get(projectCategory.Id);
Assert.True(updatedQT.ProjectCategories.Contains(updatedSP));
Assert.True(updatedSP.QuestionTemplates.Contains(updatedQT));
Assert.Equal(nActive + 1, service.ActiveQuestions(projectCategory).Count());
Assert.Equal(nTemplates, service.GetAll().Count());
/* Adding the same QuestionTemplate should fail */
Assert.Throws <Exception>(() =>
service.AddToProjectCategory(template.Id, projectCategory.Id)
);
}
public void GetDoesNotExist()
{
QuestionTemplateService questionTemplateService = new QuestionTemplateService(_context);
Assert.Throws <NotFoundInDBException>(() => questionTemplateService.GetQuestionTemplate("some_action_id_that_does_not_exist"));
}
