public Answer MapToAnswer(Dtos.Wizard.IQuestion dto)
{
Answer answer;
if (dto is Dtos.Wizard.IQuestionChoice choiceAnswer)
{
var choices = choiceAnswer.Choices
.Select(x => new Choice {
Content = x.Content, Valid = x.Valid
})
.ToList();
answer = new ChoiceAnswer(choices,
choiceAnswer.ChoiceAnswerType,
choiceAnswer.Score,
choiceAnswer.AllValidChoicesRequired);
}
else if (dto is Dtos.Wizard.IQuestionWritten writtenAnswer)
{
answer = new WrittenAnswer(writtenAnswer.Answer, writtenAnswer.Score);
}
else
{
throw new Exception("Cannot convert into valid Answer");
}
return(answer);
}
public async Task CreateQuestion_QuestionWithCategories_ReturnsId()
{
//arrange
var categories = new Category[] { new Category("Math", userId), new Category("Addition", userId) };
InsertCategories(categories);
var service = new QuestionService(dbContext, userContext);
float maxScore = 3f;
var answer = new WrittenAnswer("4", maxScore);
var questionContent = "2 + 2 = ?";
var categoryIds = categories.Select(x => x.Id);
//act
var result = await service.CreateQuestion(questionContent, answer, categoryIds);
//assert
var persistedQuestion = dbContext.Questions.FirstOrDefault(x => x.Id == result);
persistedQuestion.Content.Should().Be(questionContent);
var questionCategories = dbContext.QuestionCategories
.Where(x => x.QuestionId == result)
.OrderBy(x => x.CategoryId)
.Select(x => x.CategoryId).ToList();
questionCategories.Count.Should().Be(2);
questionCategories.Should().BeEquivalentTo(categoryIds);
}
private AnsweringBodyAllocation giveMeAnsweringBodyAllocation(Response data)
{
AnsweringBodyAllocation answeringBodyAllocation = null;
if (data.AnsweringDeptSesId != null)
{
Uri answeringBodyId = IdRetrieval.GetSubject("sesId", data.AnsweringDeptSesId, false, logger);
if (answeringBodyId != null)
{
answeringBodyAllocation = new AnsweringBodyAllocation()
{
Id = GenerateNewId(),
AnsweringBodyAllocationHasAnsweringBody = new AnsweringBody()
{
Id = answeringBodyId
}
};
WrittenAnswer writtenAnswer = giveMeWrittenAnswer(data);
if (writtenAnswer != null)
{
answeringBodyAllocation
.AnsweringBodyAllocationHasAnsweringBody
.AnsweringBodyHasWrittenAnswer = new WrittenAnswer[] { writtenAnswer }
}
;
}
else
{
logger.Warning($"Answering body with Ses Id ({data.AnsweringDeptSesId}) not found");
}
}
return(answeringBodyAllocation);
}
public void WrittenAnswer_WrittenUserAnswer_ReturnsMaxScore()
{
int questionId = 7;
string validAnswer = "valid answer";
float maxScore = 6f;
Answer answer = new WrittenAnswer(questionId, validAnswer, maxScore);
var score = answer.GetScore(new WrittenUserAnswer(validAnswer, 1, questionId, 1));
score.Should().Be(maxScore);
}
public override BaseResource[] SynchronizeIds(BaseResource[] source, Uri subjectUri, BaseResource[] target)
{
IndexingAndSearchWrittenQuestion question = source.OfType <IndexingAndSearchWrittenQuestion>().SingleOrDefault();
question.Id = subjectUri;
if ((question.QuestionHasAnsweringBodyAllocation != null) && (question.QuestionHasAnsweringBodyAllocation.Any()))
{
AnsweringBodyAllocation answeringBodyAllocationTarget = target.OfType <AnsweringBodyAllocation>().SingleOrDefault();
if (answeringBodyAllocationTarget != null)
{
question.QuestionHasAnsweringBodyAllocation.SingleOrDefault().Id = answeringBodyAllocationTarget.Id;
}
if (question.QuestionHasAnsweringBodyAllocation.SingleOrDefault()?.AnsweringBodyAllocationHasAnsweringBody?.AnsweringBodyHasWrittenAnswer != null)
{
question.QuestionHasAnsweringBodyAllocation
.SingleOrDefault()
.AnsweringBodyAllocationHasAnsweringBody
.AnsweringBodyHasWrittenAnswer
.SingleOrDefault()
.AnswerHasQuestion = new Question[]
{
new Question()
{
Id = subjectUri
}
};
WrittenAnswer answerTarget = target.OfType <WrittenAnswer>().SingleOrDefault();
if (answerTarget != null)
{
question.QuestionHasAnsweringBodyAllocation
.SingleOrDefault()
.AnsweringBodyAllocationHasAnsweringBody
.AnsweringBodyHasWrittenAnswer
.SingleOrDefault()
.Id = answerTarget.Id;
}
}
}
if ((question.QuestionHasWrittenAnswerExpectation != null) && (question.QuestionHasWrittenAnswerExpectation.Any()))
{
WrittenAnswerExpectation expectationTarget = target.OfType <WrittenAnswerExpectation>().SingleOrDefault();
if (expectationTarget != null)
{
question.QuestionHasWrittenAnswerExpectation
.SingleOrDefault()
.Id = expectationTarget.Id;
}
}
return(new BaseResource[] { question });
}
public async Task UpdateQuestion_MethodExpectsQuestionInTheCache_ThrowsException()
{
//arrange
var question = GetNewQuestionWithWrittenAnswer();
InsertQuestion(question);
dbContext.Questions.Local.Clear();
var service = new QuestionService(dbContext, userContext);
var newAnswer = new WrittenAnswer("New answer", 3f);
//act
Func <Task <OperationResult <Unit> > > codeUnderTest = async() => await service.UpdateQuestion(question.Id, "New content", newAnswer, null);
//assert
await codeUnderTest.Should().ThrowExactlyAsync <ValueNotInTheCacheException>();
}
public async Task <OperationResult <Paginated <QuestionHeaderDto> > > GetQuestionHeaders(int authorId, int offset, int limit)
{
var questionTests = await dbContext
.Questions
.FromSqlInterpolated($"SELECT Id, Content from Questions WHERE AuthorId = {authorId} ORDER BY Id DESC OFFSET {offset} ROWS FETCH NEXT {limit + 1} ROWS ONLY")
.Include(x => x.Answer)
.GroupJoin(dbContext.TestItems,
x => x.Id,
y => y.QuestionId,
(x, y) => new { x.Id, x.Content, x.Answer, TestItem = y })
.SelectMany(x => x.TestItem.DefaultIfEmpty(),
(x, y) => new { x.Id, x.Content, x.Answer, TestItem = y })
.ToArrayAsync();
var idHeaderDtos = new Dictionary <int, QuestionHeaderDto>();
foreach (var question in questionTests)
{
if (idHeaderDtos.ContainsKey(question.Id))
{
if (question.TestItem != null)
{
idHeaderDtos[question.Id].NumberOfTimesUsedInTests++;
}
}
else
{
var questionHeaderDto = new QuestionHeaderDto
{
Id = question.Id,
Content = question.Content,
NumberOfTimesUsedInTests = question.TestItem == null ? 0 : 1,
Type = question.Answer switch
{
WrittenAnswer writtenAnswer => "Written",
ChoiceAnswer choiceAnswer => choiceAnswer.ChoiceAnswerType == ChoiceAnswerType.SingleChoice
? "Single choice"
: "Multiple choice",
_ => throw new NotImplementedException()
}
};
idHeaderDtos.Add(question.Id, questionHeaderDto);
}
}
return(new Paginated <QuestionHeaderDto>(limit, idHeaderDtos.Values));
}
public async Task ShouldNotUpdateQuestionUsedInTestThatHasStarted()
{
var authorId = fixture.UserId;
var writtenAnswer = new WrittenAnswer("answer", 1f);
var question = new Question("Question?", writtenAnswer, authorId);
await fixture.ExecuteDbContext(db =>
{
db.Questions.Add(question);
return(db.SaveChangesAsync());
});
var testTemplate = new TestTemplateBuilder(authorId, new[] { question.Id }).Build();
await fixture.ExecuteDbContext(db =>
{
db.TestTemplates.Add(testTemplate);
return(db.SaveChangesAsync());
});
var scheduledTest = new ScheduledTestBuilder(
testTemplate.Id,
IntegrationTestsDateTimeProvider.utcNow)
.SetAsCurrentlyAvailable()
.WithUsers(new[] { 2, 3, 4 })
.Build();
await fixture.ExecuteDbContext(db =>
{
db.ScheduledTests.Add(scheduledTest);
return(db.SaveChangesAsync());
});
var updateQuestionDto = new QuestionWithWrittenAnswerDto
{
Answer = "new answer",
Question = "new question",
Score = 1f,
Categories = new List <int>(),
};
var json = fixture.Serialize(updateQuestionDto);
var response = await fixture.RequestSender.PostAsync($"questions/{question.Id}", json);
response.StatusCode.Should().Be(HttpStatusCode.BadRequest);
}
public async Task CreateQuestion_QuestionWithoutCategories_ReturnsId()
{
//arrange
var service = new QuestionService(dbContext, userContext);
float maxScore = 3f;
var answer = new WrittenAnswer("4", maxScore);
var questionContent = "2 + 2 = ?";
//act
var result = await service.CreateQuestion(questionContent, answer, Enumerable.Empty <int>());
//assert
var persistedQuestion = dbContext.Questions.FirstOrDefault(x => x.Id == result);
persistedQuestion.Content.Should().Be(questionContent);
var numberOfCategories = dbContext.QuestionCategories.Where(x => x.QuestionId == result).Count();
numberOfCategories.Should().Be(0);
}
public async Task ShouldNotDeleteQuestionUsedInTestTemplate()
{
var authorId = fixture.UserId;
var writtenAnswer = new WrittenAnswer("answer", 1f);
var question = new Question("Question?", writtenAnswer, authorId);
await fixture.ExecuteDbContext(db =>
{
db.Questions.Add(question);
return(db.SaveChangesAsync());
});
var testTemplate = new TestTemplate("new test template", authorId, new int[] { question.Id });
await fixture.ExecuteDbContext(db =>
{
db.TestTemplates.Add(testTemplate);
return(db.SaveChangesAsync());
});
var response = await fixture.RequestSender.DeleteAsync($"questions/{question.Id}");
response.StatusCode.Should().Be(HttpStatusCode.BadRequest);
}
public async Task CreateQuestion_WrittenAnswer_ReturnsId()
{
//arrange
var service = new QuestionService(dbContext, userContext);
float maxScore = 3f;
var answerValue = "4";
var answer = new WrittenAnswer(answerValue, maxScore);
var questionContent = "2 + 2 = ?";
//act
var result = await service.CreateQuestion(questionContent, answer, Enumerable.Empty <int>());
//assert
var persistedQuestion = dbContext.Questions
.Include(x => x.Answer)
.FirstOrDefault(x => x.Id == result);
persistedQuestion.Content.Should().Be(questionContent);
var persistedAnswer = persistedQuestion.Answer as WrittenAnswer;
persistedAnswer.MaxScore.Should().Be(maxScore);
persistedAnswer.Value.Should().Be(answerValue);
}
public void MapToAnswer_QuestionWithWritenAnswerDto_ValidAnswer()
{
//arrange
var answerValue = "answer content";
var score = 5f;
Dtos.Wizard.QuestionDto dto = new Dtos.Wizard.QuestionWithWrittenAnswerDto
{
Id = 1,
Answer = answerValue,
Categories = new List <int>(),
Question = "Question content",
Score = score
};
var expectedAnswer = new WrittenAnswer(answerValue, score);
//act
var mapper = new QuestionServiceMapper();
var answer = mapper.MapToAnswer(dto);
//assert
answer.Should().BeEquivalentTo(expectedAnswer);
}
private WrittenAnswer giveMeWrittenAnswer(Response data)
{
WrittenAnswer writtenAnswer = null;
if ((string.IsNullOrWhiteSpace(data.AnswerText) == false) || (data.DateOfAnswer.HasValue))
{
writtenAnswer = new WrittenAnswer()
{
Id = GenerateNewId(),
AnswerText = DeserializerHelper.GiveMeSingleTextValue(data.AnswerText),
AnswerGivenDate = data.DateOfAnswer
};
if (!string.IsNullOrWhiteSpace(data.AnsweringMemberSesId))
{
Uri ministerId = GetMemberId(data.AnsweringMemberSesId, data.DateOfAnswer, logger);
if (ministerId != null)
{
writtenAnswer.AnswerHasAnsweringPerson = new Person[]
{
new Person()
{
Id = ministerId
}
}
}
;
else
{
logger.Warning($"Minister with Ses Id ({data.AnsweringMemberSesId}) not found");
}
}
}
return(writtenAnswer);
}
public async Task ShouldReturnAllQuestions()
{
int authorId = fixture.UserId;
var questions = new List <Question>();
var choices = new List <Choice>()
{
new Choice {
Valid = false, Content = "1957"
},
new Choice {
Valid = true, Content = "1958"
},
new Choice {
Valid = false, Content = "1959"
},
new Choice {
Valid = false, Content = "1960"
},
new Choice {
Valid = false, Content = "1961"
},
new Choice {
Valid = false, Content = "1962"
}
};
var choiceAnswer = new ChoiceAnswer(choices, ChoiceAnswerType.SingleChoice, 1f);
questions.Add(new Question("When was Nasa founded?", choiceAnswer, authorId));
choices = new List <Choice>()
{
new Choice {
Valid = false, Content = "99 years"
},
new Choice {
Valid = false, Content = "100 years"
},
new Choice {
Valid = false, Content = "113 years"
},
new Choice {
Valid = true, Content = "116 years"
}
};
choiceAnswer = new ChoiceAnswer(choices, ChoiceAnswerType.SingleChoice, 1f);
questions.Add(new Question("How many years did the 100 years war last?", choiceAnswer, authorId));
var writtenAnswer = new WrittenAnswer("George Washington", 1f);
questions.Add(new Question("Who was the first president of the United States?", writtenAnswer, authorId));
await fixture.ExecuteDbContext(db =>
{
foreach (var question in questions)
{
db.Questions.Add(question);
}
return(db.SaveChangesAsync());
});
var mapper = new QuestionServiceMapper();
var questionDtos = questions.Select(mapper.MapToWizardQuestionDto);
int offset = 0;
int limit = 10;
var queryString = $"?Offset={offset}&Limit={limit}";
var response = await fixture.RequestSender.GetAsync("questions" + queryString);
response.StatusCode.Should().Be(HttpStatusCode.OK);
var responseData = await response.Content.ReadAsStringAsync();
var result = fixture.Deserialize <Paginated <QuestionDto> >(responseData);
result.Data.Should().NotBeEmpty();
foreach (var questionDto in questionDtos)
{
result.Data.Should().ContainEquivalentOf(questionDto);
}
}
