private async Task CreateQuestions(HttpClient client)
{
var httpCallHelper = new HttpCallHelper(client);
//u means user
u1PublicNotPublished = await httpCallHelper.CreateQuestion();
u1PublicPublished = await httpCallHelper.CreateQuestion(loggedUser : u1PublicNotPublished.Item1);
u1PrivateNotPublished = await httpCallHelper.CreateQuestion(loggedUser : u1PublicNotPublished.Item1, isPrivate : true);
u1PrivatePublished = await httpCallHelper.CreateQuestion(loggedUser : u1PublicNotPublished.Item1, isPrivate : true);
u2PublicNotPublished = await httpCallHelper.CreateQuestion();
u2PublicPublished = await httpCallHelper.CreateQuestion(loggedUser : u2PublicNotPublished.Item1);
u2PrivateNotPublished = await httpCallHelper.CreateQuestion(loggedUser : u2PublicNotPublished.Item1, isPrivate : true);
u2PrivatePublished = await httpCallHelper.CreateQuestion(loggedUser : u2PublicNotPublished.Item1, isPrivate : true);
//publishing exams
client.Authorize(u1PublicNotPublished.Item1.Token);
await httpCallHelper.PublishExam(u1PublicPublished.Item3.Id);
await httpCallHelper.PublishExam(u1PrivatePublished.Item3.Id);
client.Authorize(u2PublicNotPublished.Item1.Token);
await httpCallHelper.PublishExam(u2PublicPublished.Item3.Id);
await httpCallHelper.PublishExam(u2PrivatePublished.Item3.Id);
client.Unauthorize();
}
public async void ShouldEditTests()
{
var client = httpClientFactory.CreateClient();
var httpCallHelper = new HttpCallHelper(client);
var questionItems = await httpCallHelper.CreateQuestion();
var questionItemsPublished = await httpCallHelper.CreateQuestion(loggedUser : questionItems.Item1);
var questionItems2 = await httpCallHelper.CreateQuestion();
var question1 = questionItems.Item5;
var question2 = questionItems2.Item5;
var questionPublished = questionItemsPublished.Item5;
var examPublished = questionItemsPublished.Item3;
var user1 = questionItems.Item1;
var radioQuestionData = TestData.Question.Edit.NewQuestionData();
var checkboxQuestionData = TestData.Question.Edit.NewQuestionData(false);
var link1 = $"/questions/{question1.Id}";
var link2 = $"/questions/{question2.Id}";
var linkPublished = $"/questions/{questionPublished.Id}";
await client.PutUnauthorized(link1, new Edit.Request()
{
Question = radioQuestionData
});
client.Authorize(user1.Token);
var tempQuestion = TestData.Question.Edit.NewQuestionDataWithEmptyText();
await client.PutBadRequest(link1, new Edit.Request()
{
Question = tempQuestion
});
tempQuestion = TestData.Question.Edit.NewQuestionDataWithTooLongText();
await client.PutBadRequest(link1, new Edit.Request()
{
Question = tempQuestion
});
tempQuestion = TestData.Question.Edit.NewQuestionDataWithFewerAnswerOption();
await client.PutBadRequest(link1, new Edit.Request()
{
Question = tempQuestion
});
tempQuestion = TestData.Question.Edit.NewQuestionDataWithMoreAnswerOption();
await client.PutBadRequest(link1, new Edit.Request()
{
Question = tempQuestion
});
tempQuestion = TestData.Question.Edit.NewQuestionDataRadioWithTwoRight();
await client.PutBadRequest(link1, new Edit.Request()
{
Question = tempQuestion
});
tempQuestion = TestData.Question.Edit.NewQuestionDataCheckboxWithSingleRight();
await client.PutBadRequest(link1, new Edit.Request()
{
Question = tempQuestion
});
tempQuestion = TestData.Question.Edit.NewQuestionDataWithAllRight();
await client.PutBadRequest(link1, new Edit.Request()
{
Question = tempQuestion
});
tempQuestion = TestData.Question.Edit.NewQuestionDataWithAllWrong();
await client.PutBadRequest(link1, new Edit.Request()
{
Question = tempQuestion
});
tempQuestion = TestData.Question.Edit.NewQuestionDataWithAllRight(false);
await client.PutBadRequest(link1, new Edit.Request()
{
Question = tempQuestion
});
tempQuestion = TestData.Question.Edit.NewQuestionDataWithAllWrong(false);
await client.PutBadRequest(link1, new Edit.Request()
{
Question = tempQuestion
});
tempQuestion = TestData.Question.Edit.NewQuestionDataWithEmptyAnswerText();
await client.PutBadRequest(link1, new Edit.Request()
{
Question = tempQuestion
});
tempQuestion = TestData.Question.Edit.NewQuestionDataWithTooLongAnswerText();
await client.PutBadRequest(link1, new Edit.Request()
{
Question = tempQuestion
});
//other user's exam
await client.PutNotFound(link2, new Edit.Request()
{
Question = radioQuestionData
});
//edit published exam question
await client.PutSucessfully(linkPublished, new Edit.Request()
{
Question = radioQuestionData
});
await httpCallHelper.PublishExam(examPublished.Id);
await client.PutNotFound(linkPublished, new Edit.Request()
{
Question = radioQuestionData
});
//sucess
//null text and null answer
var questionData = TestData.Question.Edit.NewQuestionDataWithNullTextAndAnswer();
var resultDto = await client.PutQuestionSucessfully(link1, new Edit.Request()
{
Question = questionData
});
AssertHelper.AssertEqual(question1, resultDto);
//null text and same answers
questionData = mapper.Mapper.Map <Edit.QuestionData>(resultDto);
questionData.Text = null;
resultDto = await client.PutQuestionSucessfully(link1, new Edit.Request()
{
Question = questionData
});
AssertHelper.AssertEqual(question1, resultDto);
//same text and null answers
questionData = mapper.Mapper.Map <Edit.QuestionData>(resultDto);
questionData.Answers = null;
resultDto = await client.PutQuestionSucessfully(link1, new Edit.Request()
{
Question = questionData
});
AssertHelper.AssertEqual(question1, resultDto);
//with new answer
questionData = mapper.Mapper.Map <Edit.QuestionData>(resultDto);
var count = questionData.Answers.Count();
var answers = new List <Edit.AnswerData>(questionData.Answers);
var newAnserOptionData = TestData.Question.Edit.GenerateAnswerOption(count);
answers.Add(newAnserOptionData);
questionData.Answers = answers;
resultDto = await client.PutQuestionSucessfully(link1, new Edit.Request()
{
Question = questionData
});
AssertHelper.AssertNotEqual(question1, resultDto);
Assert.True(question1.UpdatedAt < resultDto.UpdatedAt);
Assert.True(resultDto.AnswerOptions.Count() == count + 1);
var answerOptions = resultDto.AnswerOptions.OrderByDescending(e => e.Id).ToArray();
var answerOptionAdded = answerOptions[0];
AssertHelper.AssertEqual(answerOptionAdded, newAnserOptionData);
//only added anser changed.
for (int i = 1; i < answerOptions.Length; i++)
{
var ao = answerOptions[i];
Assert.True(ao.UpdatedAt < answerOptionAdded.UpdatedAt);
}
question1 = resultDto;
//with new text
questionData = mapper.Mapper.Map <Edit.QuestionData>(resultDto);
questionData.Text = questionData.Text + "_NewOne";
resultDto = await client.PutQuestionSucessfully(link1, new Edit.Request()
{
Question = questionData
});
AssertHelper.AssertNotEqual(question1, resultDto);
Assert.True(question1.Text != resultDto.Text);
Assert.True(question1.UpdatedAt < resultDto.UpdatedAt);
foreach (var ao in resultDto.AnswerOptions)
{
Assert.True(ao.UpdatedAt < resultDto.UpdatedAt);
}
question1 = resultDto;
//with new answer and deleted and edited
questionData = mapper.Mapper.Map <Edit.QuestionData>(resultDto);
count = questionData.Answers.Count();
answers = new List <Edit.AnswerData>(questionData.Answers);
newAnserOptionData = TestData.Question.Edit.GenerateAnswerOption(count);
var answerEdited = answers.First();
answerEdited.Text = answerEdited.Text + "_Edited";
var answerDeleted = answers.Where(e => e.Id != answerEdited.Id && !e.IsRight).Last();
var answerUnchanged = answers.Where(e => e.Id != answerEdited.Id && e.Id != answerDeleted.Id && !e.IsRight).Last();
answerUnchanged.Text = null;
answers.Add(newAnserOptionData);
answers.Remove(answerDeleted);
questionData.Answers = answers;
resultDto = await client.PutQuestionSucessfully(link1, new Edit.Request()
{
Question = questionData
});
AssertHelper.AssertNotEqual(question1, resultDto);
Assert.True(question1.UpdatedAt < resultDto.UpdatedAt);
Assert.True(resultDto.AnswerOptions.Count() == count);
answerOptions = resultDto.AnswerOptions.OrderByDescending(e => e.Id).ToArray();
answerOptionAdded = answerOptions[0];
var answerOptionEdited = answerOptions.Where(e => e.Id == answerEdited.Id).First();
var answerOptionUnchanged = answerOptions.Where(e => e.Id == answerUnchanged.Id).First();
AssertHelper.AssertEqual(answerOptionAdded, newAnserOptionData);
AssertHelper.AssertEqual(answerOptionEdited, answerEdited);
Assert.True(resultDto.UpdatedAt == answerOptionEdited.UpdatedAt);
Assert.True(answerOptionAdded.UpdatedAt == answerOptionEdited.UpdatedAt);
Assert.True(answerOptionUnchanged.Text.Length > 1);
Assert.True(answerOptionUnchanged.UpdatedAt < answerOptionEdited.UpdatedAt);
foreach (var ao in resultDto.AnswerOptions)
{
Assert.True(ao.Id != answerDeleted.Id);
if (ao.Id != answerOptionAdded.Id && ao.Id != answerOptionEdited.Id)
{
Assert.True(ao.UpdatedAt < answerOptionEdited.UpdatedAt);
}
}
question1 = resultDto;
// some ok cases
tempQuestion = TestData.Question.Edit.NewQuestionDataWithNullAnswerOption();
await client.PutSucessfully(link1, new Edit.Request()
{
Question = tempQuestion
});
tempQuestion = TestData.Question.Edit.NewQuestionDataWithNullText();
await client.PutSucessfully(link1, new Edit.Request()
{
Question = tempQuestion
});
tempQuestion = TestData.Question.Edit.NewQuestionDataWithEmptyAnswerOption();
await client.PutSucessfully(link1, new Edit.Request()
{
Question = tempQuestion
});
}
public async void AllListTests()
{
var client = httpClientFactory.CreateClient();
var data = new QuestionTestData(client);
var helper = new HttpCallHelper(client);
client.Unauthorize();
var u1PublicNotPublishedLink = $"/questions?examId={data.u1PublicNotPublished.Item3.Id}";
var u1PublicPublishedLink = $"/questions?examId={data.u1PublicPublished.Item3.Id}";
var u1PrivateNotPublishedLink = $"/questions?examId={data.u1PrivateNotPublished.Item3.Id}";
var u1PrivatePublishedLink = $"/questions?examId={data.u1PrivatePublished.Item3.Id}";
var u2PublicNotPublishedLink = $"/questions?examId={data.u2PublicNotPublished.Item3.Id}";
var u2PublicPublishedLink = $"/questions?examId={data.u2PublicPublished.Item3.Id}";
var u2PrivateNotPublishedLink = $"/questions?examId={data.u2PrivateNotPublished.Item3.Id}";
var u2PrivatePublishedLink = $"/questions?examId={data.u2PrivatePublished.Item3.Id}";
var linkNoneExisting = $"/questions?examId={int.MaxValue}";
await client.GetNotFound(linkNoneExisting);
//user 1
await client.GetNotFound(u1PublicNotPublishedLink);
var questionsEnvelope = await client.GetQuestionsSuccesfully(u1PublicPublishedLink);
Assert.Equal(questionsEnvelope.QuestionCount, questionsEnvelope.Questions.Count());
Assert.Equal(1, questionsEnvelope.QuestionCount);
Assert.Equal(0, questionsEnvelope.Questions.First().AnswerOptions.Count);
await client.GetNotFound(u1PrivateNotPublishedLink);
await client.GetNotFound(u1PrivatePublishedLink);
//user 2
await client.GetNotFound(u2PublicNotPublishedLink);
questionsEnvelope = await client.GetQuestionsSuccesfully(u2PublicPublishedLink);
Assert.Equal(questionsEnvelope.QuestionCount, questionsEnvelope.Questions.Count());
Assert.Equal(1, questionsEnvelope.QuestionCount);
Assert.Equal(0, questionsEnvelope.Questions.First().AnswerOptions.Count);
await client.GetNotFound(u2PrivateNotPublishedLink);
await client.GetNotFound(u2PrivatePublishedLink);
//includeAnswerOptions
questionsEnvelope = await client.GetQuestionsSuccesfully($"{u1PublicPublishedLink}&includeAnswerOptions=true");
Assert.Equal(questionsEnvelope.QuestionCount, questionsEnvelope.Questions.Count());
Assert.Equal(1, questionsEnvelope.QuestionCount);
Assert.Equal(data.u1PublicPublished.Item5.AnswerOptions.Count, questionsEnvelope.Questions.First().AnswerOptions.Count);
// limit , offset
for (int i = 0; i < 11; i++)
{
await helper.CreateQuestionInExam(
data.u1PublicNotPublished.Item1.Token,
data.u1PublicNotPublished.Item3.Id, i % 2 == 0);
}
client.Authorize(data.u1PublicNotPublished.Item1.Token);
await helper.PublishExam(data.u1PublicNotPublished.Item3.Id);
client.Unauthorize();
var limitOffsetTester = new LimitOffsetTester(client, u1PublicPublishedLink);
await limitOffsetTester.DoTest(QuestionHelper.GetQuestions);
}
public async void ShouldDeleteTests()
{
var client = httpClientFactory.CreateClient();
var httpCallHelper = new HttpCallHelper(client);
var dbContextHelper = new DbContextHelper(this.dbContextFactory);
var questionItems = await httpCallHelper.CreateQuestion();
var questionItemsPublished = await httpCallHelper.CreateQuestion(loggedUser : questionItems.Item1);
var examPublished = questionItemsPublished.Item3;
var questionItems2 = await httpCallHelper.CreateQuestion();
var question1 = questionItems.Item5;
var question2 = questionItems2.Item5;
var questionPublished = questionItemsPublished.Item5;
var user1 = questionItems.Item1;
var link1 = $"/questions/{question1.Id}";
var link2 = $"/questions/{question2.Id}";
var linkPublished = $"/questions/{questionPublished.Id}";
var linkNoneExisting = $"/questions/{int.MaxValue}";
await client.DeleteUnauthorized(link1);
client.Authorize(user1.Token);
//publishing exam
await httpCallHelper.PublishExam(examPublished.Id);
await client.DeleteNotFound(linkNoneExisting);
await client.DeleteNotFound(link2);
await client.DeleteNotFound(linkPublished);
await client.DeleteSucessfully(link1);
var count = dbContextHelper.SelectQuestionCount(question1.Id);
Assert.Equal(0, count);
count = dbContextHelper.SelectQuestionCount(question2.Id);
Assert.Equal(1, count);
count = dbContextHelper.SelectQuestionCount(questionPublished.Id);
Assert.Equal(1, count);
foreach (var answerOption in question1.AnswerOptions)
{
count = dbContextHelper.SelectAnswerOptionCount(answerOption.Id);
Assert.Equal(0, count);
}
foreach (var answerOption in question2.AnswerOptions)
{
count = dbContextHelper.SelectAnswerOptionCount(answerOption.Id);
Assert.Equal(1, count);
}
foreach (var answerOption in questionPublished.AnswerOptions)
{
count = dbContextHelper.SelectAnswerOptionCount(answerOption.Id);
Assert.Equal(1, count);
}
}
public async void ShouldSelectPublishedExams()
{
var client = httpClientFactory.CreateClient();
var httpCallHelper = new HttpCallHelper(client);
var dbContextHelper = new DbContextHelper(this.dbContextFactory);
//create at least two public and two private exams
var tuple = await httpCallHelper.CreateExam();
var examPublicDto1 = tuple.Item3;
tuple = await httpCallHelper.CreateExam();
var examPublicDto2 = tuple.Item3;
tuple = await httpCallHelper.CreateExam(true, true);
var examPrivateDto1 = tuple.Item3;
tuple = await httpCallHelper.CreateExam(true, true);
var examPrivateDto2 = tuple.Item3;
await dbContextHelper.SetPublishExamAsync(examPublicDto1.Id);
await dbContextHelper.SetPublishExamAsync(examPublicDto2.Id);
await dbContextHelper.SetPublishExamAsync(examPrivateDto1.Id);
await dbContextHelper.SetPublishExamAsync(examPrivateDto2.Id);
var getLink = "exams";
var getLinkIncludeTags = "exams?includeTags=true";
var getLinkIncludeUser = "******";
var getLinkIncludeTagsAndUser = "******";
//no user and tags
var responseExams = await client.GetExamsSuccesfully(getLink);
foreach (var exam in responseExams)
{
Assert.True(exam.IsPublished);
Assert.False(exam.IsPrivate);
AssertHelper.AssertNoUserAndNoTagsIncluded(exam);
}
//with tags
responseExams = await client.GetExamsSuccesfully(getLinkIncludeTags);
foreach (var exam in responseExams)
{
Assert.True(exam.IsPublished);
Assert.False(exam.IsPrivate);
AssertHelper.AssertOnlyTagsIncluded(exam);
}
//with user
responseExams = await client.GetExamsSuccesfully(getLinkIncludeUser);
foreach (var exam in responseExams)
{
Assert.True(exam.IsPublished);
Assert.False(exam.IsPrivate);
AssertHelper.AssertOnlyUserIncluded(exam);
}
//with tags and user
responseExams = await client.GetExamsSuccesfully(getLinkIncludeTagsAndUser);
foreach (var exam in responseExams)
{
Assert.True(exam.IsPublished);
Assert.False(exam.IsPrivate);
Assert.NotNull(exam.User);
if (exam.Id == examPublicDto2.Id || exam.Id == examPublicDto1.Id)
{
Assert.True(exam.Tags.Count > 0);
}
}
//limit, ofset tests...
//creating some exams
for (int i = 0; i < 11; i++)
{
tuple = await httpCallHelper.CreateExam();
var examId = tuple.Item3.Id;
var token = tuple.Item1.Token;
client.Authorize(token);
await httpCallHelper.PublishExam(examId);
}
var limitOffsetTester = new LimitOffsetTester(client, getLink);
await limitOffsetTester.DoTest(GetExams);
}