public async void UserExamResultCreateTests()
{
var client = httpClientFactory.CreateClient();
var httpCallHelper = new HttpCallHelper(client);
var testHelper = new UserExamResultTestHelper(client, dbContextFactory);
var dbContextHelper = new DbContextHelper(dbContextFactory);
var random = Utils.NewRandom();
var userExam1 = await httpCallHelper.CreateUserExam(questionCount : random.Next(50, 100));
var userExam2 = await httpCallHelper.CreateUserExam(questionCount : random.Next(50, 100));
var userExam3 = await httpCallHelper.CreateUserExam(questionCount : random.Next(50, 100));
var userExam4 = await httpCallHelper.CreateUserExam(questionCount : random.Next(50, 100));
//unautorized
client.Unauthorize();
await client.PostUnauthorized($"/userexamresults/{userExam1.Item3.Id}");
//not existing
client.Authorize(userExam1.Item1.Token);
await client.PostNotFound($"/userexamresults/{int.MaxValue}");
//not published
var userExamNotPublished = await httpCallHelper.CreateUserExam();
await dbContextHelper.SetPublishExamAsync(userExamNotPublished.Item2.Id, false);
client.Authorize(userExamNotPublished.Item1.Token);
await client.PostNotFound($"/userexamresults/{userExamNotPublished.Item3.Id}");
//not ended exam
var userExamNotEnded = await httpCallHelper.CreateUserExam();
client.Authorize(userExamNotEnded.Item1.Token);
await client.PostNotFound($"/userexamresults/{userExamNotEnded.Item3.Id}");
await dbContextHelper.UpdateUserExamStartDate(userExamNotEnded.Item3.Id, userExamNotEnded.Item2.TimeInMinutes * -2);
await client.PostUserExamResultSucessfully($"/userexamresults/{userExamNotEnded.Item3.Id}");
//get existing one
await client.PostUserExamResultSucessfully($"/userexamresults/{userExamNotEnded.Item3.Id}");
client.Authorize(userExam1.Item1.Token);
await testHelper.TakeExamAndAssertResult(httpCallHelper, userExam1.Item3.Id, false, false);
//other users
client.Authorize(userExam2.Item1.Token);
await client.PostNotFound($"/userexamresults/{userExam2.Item3.Id}");
client.Authorize(userExam2.Item1.Token);
await testHelper.TakeExamAndAssertResult(httpCallHelper, userExam2.Item3.Id, false, true);
client.Authorize(userExam3.Item1.Token);
await testHelper.TakeExamAndAssertResult(httpCallHelper, userExam3.Item3.Id, true, false);
client.Authorize(userExam4.Item1.Token);
await testHelper.TakeExamAndAssertResult(httpCallHelper, userExam4.Item3.Id, true, true);
}
public async void ShouldFailEditOtherUserExamAndPublishedExam()
{
var client = httpClientFactory.CreateClient();
var httpCallHelper = new HttpCallHelper(client);
var dbContextHelper = new DbContextHelper(this.dbContextFactory);
var tuple = await httpCallHelper.CreateExam();
var loggedUser1 = tuple.Item1;
var examDto1 = tuple.Item3;
tuple = await httpCallHelper.CreateExam();
var loggedUser2 = tuple.Item1;
var examDto2 = tuple.Item3;
var putLink1 = $"/exams/{examDto1.Id}";
var putLink2 = $"/exams/{examDto2.Id}";
client.Authorize(loggedUser1.Token);
await client.PutNotFound(putLink2, new Edit.Request()
{
Exam = new Edit.ExamData()
});
await client.PutExamSuccesfully(putLink1, new Edit.Request()
{
Exam = new Edit.ExamData()
});
await dbContextHelper.SetPublishExamAsync(examDto1.Id);
await client.PutNotFound(putLink1, new Edit.Request()
{
Exam = new Edit.ExamData()
});
}
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 ShouldFailEditExamWithInvalidData()
{
var client = httpClientFactory.CreateClient();
var httpCallHelper = new HttpCallHelper(client);
var tuple = await httpCallHelper.CreateExam();
var loggedUser = tuple.Item1;
var examDto = tuple.Item3;
var putLink = $"/exams/{examDto.Id}";
var examData = new Edit.ExamData()
{
Title = "",
Description = "",
TimeInMinutes = 0,
PassPercentage = 0,
IsPrivate = !examDto.IsPrivate,
Tags = new string[] { }
};
client.Authorize(loggedUser.Token);
var problemDetails = await client.PutBadRequest(putLink, new Edit.Request()
{
Exam = examData
});
problemDetails.Errors.Should().HaveCount(4);
}
public async void ShouldGetExamDetails()
{
var client = httpClientFactory.CreateClient();
var httpCallHelper = new HttpCallHelper(client);
var dbContextHelper = new DbContextHelper(this.dbContextFactory);
var tuple = await httpCallHelper.CreateExam();
var examPublicDto = tuple.Item3;
tuple = await httpCallHelper.CreateExam(true, true);
var examPrivateDto = tuple.Item3;
var getExamLink = $"exams/exam/{examPublicDto.Id}";
var getExamLinkIncludeUser = $"exams/exam/{examPublicDto.Id}?includeUser=true";
var getExamLinkIncludeTags = $"exams/exam/{examPublicDto.Id}?includeTags=true";
var getExamLinkIncludeUserAndTags = $"exams/exam/{examPublicDto.Id}?includeUser=true&includeTags=true";
var getPrivateExamLink = $"exams/exam/{examPrivateDto.Id}";
//not published
await client.GetNotFound(getExamLink);
await client.GetNotFound(getPrivateExamLink);
await dbContextHelper.SetPublishExamAsync(examPublicDto.Id);
await dbContextHelper.SetPublishExamAsync(examPrivateDto.Id);
//public and published
var responseExam = await client.GetExamSuccesfully(getExamLink);
AssertHelper.AssertNoUserAndNoTagsIncluded(responseExam);
//include user
responseExam = await client.GetExamSuccesfully(getExamLinkIncludeUser);
AssertHelper.AssertOnlyUserIncluded(responseExam);
//include tags
responseExam = await client.GetExamSuccesfully(getExamLinkIncludeTags);
AssertHelper.AssertOnlyTagsIncluded(responseExam);
//include user and tags
responseExam = await client.GetExamSuccesfully(getExamLinkIncludeUserAndTags);
AssertHelper.AssertUserAndTagsIncluded(responseExam);
//private and published
await client.GetNotFound(getPrivateExamLink);
}
public async void UserExamResultDetailsTests()
{
var client = httpClientFactory.CreateClient();
var httpCallHelper = new HttpCallHelper(client);
var testHelper = new UserExamResultTestHelper(client, dbContextFactory);
var dbContextHelper = new DbContextHelper(dbContextFactory);
var random = Utils.NewRandom();
var userExam1 = await httpCallHelper.CreateUserExam(questionCount : random.Next(50, 100));
var userExam2 = await httpCallHelper.CreateUserExam(questionCount : random.Next(50, 100));
var userExamNotPublished = await httpCallHelper.CreateUserExam(questionCount : random.Next(50, 100));
//creatng exam results
client.Authorize(userExam1.Item1.Token);
await testHelper.TakeExamAndAssertResult(httpCallHelper, userExam1.Item3.Id, false, true);
client.Authorize(userExam2.Item1.Token);
await testHelper.TakeExamAndAssertResult(httpCallHelper, userExam2.Item3.Id, true, true);
client.Authorize(userExamNotPublished.Item1.Token);
await testHelper.TakeExamAndAssertResult(httpCallHelper, userExamNotPublished.Item3.Id, false, true);
//unautorized
client.Unauthorize();
await client.GetUnauthorized($"/userexamresults/{userExam1.Item3.Id}");
client.Authorize(userExam1.Item1.Token);
//not existing
client.Authorize(userExam1.Item1.Token);
await client.GetNotFound($"/userexamresults/{int.MaxValue}");
//other users
await client.GetNotFound($"/userexamresults/{userExam2.Item3.Id}");
//not published
client.Authorize(userExamNotPublished.Item1.Token);
await dbContextHelper.SetPublishExamAsync(userExamNotPublished.Item2.Id, false);
await client.GetNotFound($"/userexamresults/{userExamNotPublished.Item3.Id}");
await dbContextHelper.SetPublishExamAsync(userExamNotPublished.Item2.Id, true);
await client.GetUserExamResultSuccesfully($"/userexamresults/{userExamNotPublished.Item3.Id}");
//normal cases
client.Authorize(userExam1.Item1.Token);
await client.GetUserExamResultSuccesfully($"/userexamresults/{userExam1.Item3.Id}");
client.Authorize(userExam2.Item1.Token);
await client.GetUserExamResultSuccesfully($"/userexamresults/{userExam2.Item3.Id}");
}
public async void ShouldFailCreateExamWithInvalidData()
{
var client = httpClientFactory.CreateClient();
var httpCallHelper = new HttpCallHelper(client);
var loggedUser = (await httpCallHelper.CreateUserAndLogin()).Item4;
client.Authorize(loggedUser.Token);
var problemDetails = await client.PostBadRequest("/exams", new Create.Request()
{
Exam = new Create.ExamData()
});
problemDetails.Errors.Should().HaveCount(4);
}
private async Task CreateUserExams()
{
var httpCallHelper = new HttpCallHelper(client);
this.User1PublicUserExam = await httpCallHelper.CreateUserExam();
this.User1PublicUserExam2 = await httpCallHelper.CreateUserExam(loggedUser : User1PublicUserExam.Item1);
this.User1PrivateUserExam = await httpCallHelper.CreateUserExam(loggedUser : User1PublicUserExam.Item1, isPrivate : true);
this.User2PublicUserExam = await httpCallHelper.CreateUserExam();
this.User2PublicUserExam2 = await httpCallHelper.CreateUserExam(loggedUser : User2PublicUserExam.Item1);
this.User2PrivateUserExam = await httpCallHelper.CreateUserExam(loggedUser : User2PublicUserExam.Item1, isPrivate : true);
}
public async void UserExamCreateTests()
{
var client = httpClientFactory.CreateClient();
var data = new QuestionTestData(client);
var helper = new HttpCallHelper(client);
client.Unauthorize();
var u1PublicNotPublishedLink = $"/userexams/{data.u1PublicNotPublished.Item3.Id}";
var u1PublicPublishedLink = $"/userexams/{data.u1PublicPublished.Item3.Id}";
var u1PrivateNotPublishedLink = $"/userexams/{data.u1PrivateNotPublished.Item3.Id}";
var u1PrivatePublishedLink = $"/userexams/{data.u1PrivatePublished.Item3.Id}";
var u2PublicNotPublishedLink = $"/userexams/{data.u2PublicNotPublished.Item3.Id}";
var u2PublicPublishedLink = $"/userexams/{data.u2PublicPublished.Item3.Id}";
var u2PrivateNotPublishedLink = $"/userexams/{data.u2PrivateNotPublished.Item3.Id}";
var u2PrivatePublishedLink = $"/userexams/{data.u2PrivatePublished.Item3.Id}";
var linkNoneExisting = $"/userexams/{int.MaxValue}";
await client.PostUnauthorized(u1PublicNotPublishedLink);
//login user1
client.Authorize(data.u1PublicNotPublished.Item1.Token);
await client.PostNotFound(linkNoneExisting);
await client.PostNotFound(u1PublicNotPublishedLink);
var userExamDto = await client.PostUserExamSuccesfully(u1PublicPublishedLink);
AssertHelper.AsserUserExam(userExamDto);
await client.PostNotFound(u1PrivateNotPublishedLink);
userExamDto = await client.PostUserExamSuccesfully(u1PrivatePublishedLink);
AssertHelper.AsserUserExam(userExamDto);
await client.PostNotFound(u2PublicNotPublishedLink);
userExamDto = await client.PostUserExamSuccesfully(u2PublicPublishedLink);
AssertHelper.AsserUserExam(userExamDto);
await client.PostNotFound(u2PrivateNotPublishedLink);
await client.PostNotFound(u2PrivatePublishedLink);
}
public async void ShouldDeleteExam()
{
var client = httpClientFactory.CreateClient();
var httpCallHelper = new HttpCallHelper(client);
var dbContextHelper = new DbContextHelper(this.dbContextFactory);
var tuple = await httpCallHelper.CreateExam();
var loggedUser1 = tuple.Item1;
var examDto1 = tuple.Item3;
tuple = await httpCallHelper.CreateExam();
var loggedUser2 = tuple.Item1;
var examDto2 = tuple.Item3;
var link1 = $"exams/{examDto1.Id}";
var link2 = $"exams/{examDto2.Id}";
var linkNotExists = $"exams/{int.MaxValue}";
var exam1 = await dbContextHelper.FindExamAsync(examDto1.Id);
var exam2 = await dbContextHelper.FindExamAsync(examDto2.Id);
AssertHelper.AssertExamNotDeleted(exam1);
AssertHelper.AssertExamNotDeleted(exam2);
//unauthorized
await client.DeleteUnauthorized(link1);
//not this users exam
client.Authorize(loggedUser1.Token);
await client.DeleteNotFound(link2);
//not existing
await client.DeleteNotFound(linkNotExists);
//success
var responseExam = await client.DeleteExamSucessfully(link1);
Assert.Equal(responseExam.Id, examDto1.Id);
exam1 = dbContextHelper.SelectExamFirstOrDefault(examDto1.Id);
Assert.Null(exam1);
exam1 = dbContextHelper.SelectExamIgnoreQueryFiltersTakeFirst(examDto1.Id);
AssertHelper.AssertExamDeleted(exam1);
}
public static async Task <UserQuestionAnswerData> CreateData(System.Net.Http.HttpClient client)
{
var httpCallHelper = new HttpCallHelper(client);
var user = new UserQuestionAnswerData();
var userData = await httpCallHelper.CreateUserExam();
user.User = userData.Item1;
user.Exam = userData.Item2;
user.UserExam = userData.Item3;
var questions = await httpCallHelper.GetQuestions(userData.Item2.Id);
user.Questions = questions.Questions;
user.QuestionCount = questions.QuestionCount;
user.RadioQuestion1 = questions.Questions.Where(e => e.QuestionTypeId == SeedData.QuestionTypes.Radio.Id).First();
user.RadioQuestion2 = questions.Questions.Where(e => e.QuestionTypeId == SeedData.QuestionTypes.Radio.Id && e.Id != user.RadioQuestion1.Id).First();
user.CheckboxQuestion1 = questions.Questions.Where(e => e.QuestionTypeId == SeedData.QuestionTypes.Checkbox.Id).First();
user.CheckboxQuestion2 = questions.Questions.Where(e => e.QuestionTypeId == SeedData.QuestionTypes.Checkbox.Id && e.Id != user.CheckboxQuestion1.Id).First();
user.RadioQuestion1Answer = new UserExamQuestionAnswerData()
{
UserExamId = userData.Item3.Id, QuestionId = user.RadioQuestion1.Id
};
user.RadioQuestion2Answer = new UserExamQuestionAnswerData()
{
UserExamId = userData.Item3.Id, QuestionId = user.RadioQuestion2.Id
};
user.CheckboxQuestion1Answer = new UserExamQuestionAnswerData()
{
UserExamId = userData.Item3.Id, QuestionId = user.CheckboxQuestion1.Id
};
user.CheckboxQuestion2Answer = new UserExamQuestionAnswerData()
{
UserExamId = userData.Item3.Id, QuestionId = user.CheckboxQuestion2.Id
};
user.RadioQuestion1AnswerIds = user.RadioQuestion1.AnswerOptions.Select(e => e.Id).ToArray();
user.RadioQuestion2AnswerIds = user.RadioQuestion2.AnswerOptions.Select(e => e.Id).ToArray();
user.CheckboxQuestion1AnswerIds = user.CheckboxQuestion1.AnswerOptions.Select(e => e.Id).ToArray();
user.CheckboxQuestion2AnswerIds = user.CheckboxQuestion2.AnswerOptions.Select(e => e.Id).ToArray();
return(user);
}
public async Task TakeExamAndAssertResult(
HttpCallHelper httpCallHelper,
int userExamId, bool fail, bool skipSomeQuestions = false)
{
var testResult = await TakeExam(userExamId, fail, skipSomeQuestions);
var userExamDto = await httpCallHelper.EndUserExam(userExamId);
var userExamResult = await httpCallHelper.PostUserExamResult(userExamId);
Assert.True(userExamResult.IsPassed == !fail);
Assert.True(userExamResult.RightAnswerCount == testResult.Item1);
Assert.True(userExamResult.AnsweredQuestionCount == testResult.Item2);
var passed = ((float)userExamResult.RightAnswerCount / (float)userExamResult.QuestionCount * 100) >= userExamDto.Exam.PassPercentage;
Assert.True(passed == userExamResult.IsPassed);
Assert.True(userExamResult.AnsweredQuestionCount == userExamResult.WrongAnswerCount + userExamResult.RightAnswerCount);
Assert.True(userExamResult.QuestionCount >= userExamResult.AnsweredQuestionCount);
Assert.True(userExamResult.QuestionCount == userExamResult.AnsweredQuestionCount + userExamResult.NotAnsweredQuestionCount);
}
public async void ShouldPublishExam()
{
var client = httpClientFactory.CreateClient();
var httpCallHelper = new HttpCallHelper(client);
var dbContextHelper = new DbContextHelper(this.dbContextFactory);
var tuple = await httpCallHelper.CreateExam();
var loggedUser1 = tuple.Item1;
var examDto1 = tuple.Item3;
tuple = await httpCallHelper.CreateExam();
var loggedUser2 = tuple.Item1;
var examDto2 = tuple.Item3;
var link1 = $"exams/publish/{examDto1.Id}";
var link2 = $"exams/publish/{examDto2.Id}";
//unauthorized
await client.PutUnauthorized(link1, null);
//other user's exam.
client.Authorize(loggedUser1.Token);
await client.PutNotFound(link2, null);
//already published
await dbContextHelper.SetPublishExamAsync(examDto1.Id);
await client.PutNotFound(link1, null);
//sucess
client.Authorize(loggedUser2.Token);
var responseExam = await client.PutExamSuccesfully(link2, null);
//check success
var exam2 = await dbContextHelper.FindExamAsync(examDto2.Id);
Assert.True(exam2.IsPublished);
Assert.True(responseExam.IsPublished);
}
public async void ShouldCreateExamAndFailWhenUnauthorized()
{
var client = httpClientFactory.CreateClient();
var httpCallHelper = new HttpCallHelper(client);
var dbContextHelper = new DbContextHelper(this.dbContextFactory);
var tags = SampleExamContextHelper.SeededTags.Select(e => e.TagId).ToArray();
var loggedUser = (await httpCallHelper.CreateUserAndLogin()).Item4;
var examData = TestData.Exam.Create.NewExamData(true, false, tags);
client.Authorize(loggedUser.Token);
var responseExam = await client.PostExamSuccesfully("/exams", new Create.Request()
{
Exam = examData
});
var exam = dbContextHelper.SelectExamWitTags(responseExam.Id);
AssertHelper.AssertExam(examData, responseExam, exam);
AssertHelper.AssertExamTags(examData.Tags.ToArray(), responseExam, exam);
client.Unauthorize();
await client.PostUnauthorized("/exams", new Create.Request()
{
Exam = examData
});
//should save without tags
examData.Tags = null;
client.Authorize(loggedUser.Token);
responseExam = await client.PostExamSuccesfully("/exams", new Create.Request()
{
Exam = examData
});
exam = dbContextHelper.SelectExamWitTags(responseExam.Id);
AssertHelper.AssertExam(examData, responseExam, exam);
Assert.True(responseExam.Tags.Count == 0);
Assert.True(exam.ExamTags.Count == 0);
}
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 UserExamListTests()
{
var client = httpClientFactory.CreateClient();
var httpCallHelper = new HttpCallHelper(client);
var user1 = (await httpCallHelper.CreateUserExam()).Item1;
var user2 = (await httpCallHelper.CreateUserExam()).Item1;
for (int i = 0; i < 3; i++)
{
await httpCallHelper.CreateUserExam(loggedUser : user1);
await httpCallHelper.CreateUserExam(loggedUser : user2);
await httpCallHelper.CreateUserExam(loggedUser : user1, isPrivate : true);
await httpCallHelper.CreateUserExam(loggedUser : user2, isPrivate : true);
//ended
var userExamId = (await httpCallHelper.CreateUserExam(loggedUser: user1)).Item3.Id;
client.Authorize(user1.Token);
await httpCallHelper.EndUserExam(userExamId);
userExamId = (await httpCallHelper.CreateUserExam(loggedUser: user1, isPrivate: true)).Item3.Id;
client.Authorize(user1.Token);
await httpCallHelper.EndUserExam(userExamId);
userExamId = (await httpCallHelper.CreateUserExam(loggedUser: user2)).Item3.Id;
client.Authorize(user2.Token);
await httpCallHelper.EndUserExam(userExamId);
userExamId = (await httpCallHelper.CreateUserExam(loggedUser: user2, isPrivate: true)).Item3.Id;
client.Authorize(user2.Token);
await httpCallHelper.EndUserExam(userExamId);
}
client.Unauthorize();
var link = "/userexams";
var linkIncludeExams = "/userexams?includeExams=true";
await client.GetUnauthorized(link);
client.Authorize(user1.Token);
var envelope = await client.GetUserExamsEnvelopeSuccesfully(link);
Assert.Equal(envelope.UserExamCount, envelope.UserExams.Count());
Assert.Equal(13, envelope.UserExamCount);
foreach (var userExam in envelope.UserExams)
{
Assert.Null(userExam.Exam);
Assert.Equal(userExam.UserId, user1.Id);
}
client.Authorize(user2.Token);
envelope = await client.GetUserExamsEnvelopeSuccesfully(link);
Assert.Equal(envelope.UserExamCount, envelope.UserExams.Count());
Assert.Equal(13, envelope.UserExamCount);
foreach (var userExam in envelope.UserExams)
{
Assert.Null(userExam.Exam);
Assert.Equal(userExam.UserId, user2.Id);
}
envelope = await client.GetUserExamsEnvelopeSuccesfully(linkIncludeExams);
Assert.Equal(envelope.UserExamCount, envelope.UserExams.Count());
Assert.Equal(13, envelope.UserExamCount);
foreach (var userExam in envelope.UserExams)
{
Assert.NotNull(userExam.Exam);
Assert.Equal(userExam.UserId, user2.Id);
}
var limitOffsetTester = new LimitOffsetTester(client, link);
await limitOffsetTester.DoTest(GetUserExams);
}
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 QuestionAnswerCreateOrUpdateTests()
{
var client = httpClientFactory.CreateClient();
var data = new QuestionAnswerTestData(client);
var httpCallHelper = new HttpCallHelper(client);
var dbContextHelper = new DbContextHelper(this.dbContextFactory);
client.Unauthorize();
var request = data.User1.CreateRadioQuestion1AnswerRequest();
await client.PostUnauthorized(link, request);
client.Authorize(data.User1.User.Token);
//UserExamNotFoundException 1 non existing
request = data.NonExistingRequest;
var problem = await client.PostNotFound(link, request);
//UserExamNotFoundException different user
request = data.User2.CreateRadioQuestion1AnswerRequest();
problem = await client.PostNotFound(link, request);
//UserExamAlreadyEndedException 1 really ended
client.Authorize(data.User3.User.Token);
await httpCallHelper.EndUserExam(data.User3.UserExam.Id);
request = data.User3.CreateRadioQuestion1AnswerRequest();
problem = await client.PostBadRequest(link, request);
//UserExamAlreadyEndedException 2 time is too late
client.Authorize(data.User4.User.Token);
await dbContextHelper.UpdateUserExamStartDate(data.User4.UserExam.Id, data.User4.Exam.TimeInMinutes * -1);
request = data.User4.CreateRadioQuestion1AnswerRequest();
problem = await client.PostBadRequest(link, request);
var userExam = await dbContextHelper.SelectUserExamAsync(data.User4.UserExam.Id);
Assert.NotNull(userExam.EndedAt);
//QuestionNotFoundException 1 none existing question
client.Authorize(data.User1.User.Token);
request = data.User1.CreateRadioQuestion1AnswerRequest();
request.UserExamQuestionAnswer.QuestionId = int.MaxValue;
problem = await client.PostNotFound(link, request);
//QuestionNotFoundException question of another exam
request = data.User1.CreateRadioQuestion1AnswerRequest();
var userExamDTO = (await httpCallHelper.CreateUserExam(loggedUser: data.User1.User)).Item3;
client.Authorize(data.User1.User.Token);
request.UserExamQuestionAnswer.UserExamId = userExamDTO.Id;
problem = await client.PostNotFound(link, request);
//AnswerToRadioQuestionFormatException send multiple answerss to radio
request = data.User1.CreateRadioQuestion1AnswerRequest();
var answerOptionIds = new List <int>(request.UserExamQuestionAnswer.AnswerOptionIds);
answerOptionIds.Add(data.User1.RadioQuestion1AnswerIds[0]);
answerOptionIds.Add(data.User1.RadioQuestion1AnswerIds[1]);
request.UserExamQuestionAnswer.AnswerOptionIds = answerOptionIds.Distinct().ToArray();
problem = await client.PostBadRequest(link, request);
//AnswerOptionNotFoundException
request = data.User1.CreateRadioQuestion1AnswerRequest(answerOptionIds: new int[] { int.MaxValue });
problem = await client.PostNotFound(link, request);
//InvalidAnswerOptionExamException other questions answer option.
request = data.User1.CreateRadioQuestion1AnswerRequest(answerOptionIds: new int[] { data.User2.RadioQuestion2AnswerIds.First() });
problem = await client.PostBadRequest(link, request);
await UserUpdateQuestionAnswersTest(data.User1, client);
client.Authorize(data.User2.User.Token);
await UserUpdateQuestionAnswersTest(data.User2, client);
}
public async void AllListAuthQuestionsTest()
{
var client = httpClientFactory.CreateClient();
var data = new QuestionTestData(client);
var helper = new HttpCallHelper(client);
client.Unauthorize();
var u1PublicNotPublishedLink = $"/questions/private?examId={data.u1PublicNotPublished.Item3.Id}";
var u1PublicPublishedLink = $"/questions/private?examId={data.u1PublicPublished.Item3.Id}";
var u1PrivateNotPublishedLink = $"/questions/private?examId={data.u1PrivateNotPublished.Item3.Id}";
var u1PrivatePublishedLink = $"/questions/private?examId={data.u1PrivatePublished.Item3.Id}";
var u2PublicNotPublishedLink = $"/questions/private?examId={data.u2PublicNotPublished.Item3.Id}";
var u2PublicPublishedLink = $"/questions/private?examId={data.u2PublicPublished.Item3.Id}";
var u2PrivateNotPublishedLink = $"/questions/private?examId={data.u2PrivateNotPublished.Item3.Id}";
var u2PrivatePublishedLink = $"/questions/private?examId={data.u2PrivatePublished.Item3.Id}";
var linkNoneExisting = $"/questions/private?examId={int.MaxValue}";
//login user1
client.Authorize(data.u1PublicNotPublished.Item1.Token);
await client.GetNotFound(linkNoneExisting);
var questionsEnvelope = await client.GetQuestionsSuccesfully(u1PublicNotPublishedLink);
Assert.Equal(questionsEnvelope.QuestionCount, questionsEnvelope.Questions.Count());
Assert.Equal(1, questionsEnvelope.QuestionCount);
Assert.Equal(0, questionsEnvelope.Questions.First().AnswerOptions.Count);
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);
questionsEnvelope = await client.GetQuestionsSuccesfully(u1PrivateNotPublishedLink);
Assert.Equal(questionsEnvelope.QuestionCount, questionsEnvelope.Questions.Count());
Assert.Equal(1, questionsEnvelope.QuestionCount);
Assert.Equal(0, questionsEnvelope.Questions.First().AnswerOptions.Count);
questionsEnvelope = await client.GetQuestionsSuccesfully(u1PrivatePublishedLink);
Assert.Equal(questionsEnvelope.QuestionCount, questionsEnvelope.Questions.Count());
Assert.Equal(1, questionsEnvelope.QuestionCount);
Assert.Equal(0, questionsEnvelope.Questions.First().AnswerOptions.Count);
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($"{u1PublicNotPublishedLink}&includeAnswerOptions=true");
Assert.Equal(questionsEnvelope.QuestionCount, questionsEnvelope.Questions.Count());
Assert.Equal(1, questionsEnvelope.QuestionCount);
Assert.Equal(data.u1PublicNotPublished.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);
}
//login user1
client.Authorize(data.u1PublicNotPublished.Item1.Token);
var limitOffsetTester = new LimitOffsetTester(client, u1PublicNotPublishedLink);
await limitOffsetTester.DoTest(QuestionHelper.GetQuestions);
}
public async void ShouldGetUserExamDetails()
{
var client = httpClientFactory.CreateClient();
var httpCallHelper = new HttpCallHelper(client);
//create private & public -user1
var tuple = await httpCallHelper.CreateExam();
var loggedUser1 = tuple.Item1;
var examDto1 = tuple.Item3;
tuple = await httpCallHelper.CreateExam(true, true, null, loggedUser1);
var examDtoPrivate1 = tuple.Item3;
tuple = await httpCallHelper.CreateExam();
var loggedUser2 = tuple.Item1;
var examDto2 = tuple.Item3;
tuple = await httpCallHelper.CreateExam(true, true, null, loggedUser2);
var examDtoPrivate2 = tuple.Item3;
//create private & public -user2
var link1 = $"exams/user/exam/{examDto1.Id}";
var link1IncludeUser = $"exams/user/exam/{examDto1.Id}?includeUser=true";
var link1IncludeTags = $"exams/user/exam/{examDto1.Id}?includeTags=true";
var link1IncludeUserAndTags = $"exams/user/exam/{examDto1.Id}?includeUser=true&includeTags=true";
var link1Private = $"exams/user/exam/{examDtoPrivate1.Id}";
var link1PrivateIncludeUser = $"exams/user/exam/{examDtoPrivate1.Id}?includeUser=true";
var link1PrivateIncludeTags = $"exams/user/exam/{examDtoPrivate1.Id}?includeTags=true";
var link1PrivateIncludeUserAndTags = $"exams/user/exam/{examDtoPrivate1.Id}?includeUser=true&includeTags=true";
var link2 = $"exams/user/exam/{examDto2.Id}";
//request unauthorized
await client.GetUnauthorized(link1);
//authorize user 1
client.Authorize(loggedUser1.Token);
//for public
// include none
var responseExam = await client.GetExamSuccesfully(link1);
AssertHelper.AssertNoUserAndNoTagsIncluded(responseExam);
//include user
responseExam = await client.GetExamSuccesfully(link1IncludeUser);
AssertHelper.AssertOnlyUserIncluded(responseExam);
//include tags
responseExam = await client.GetExamSuccesfully(link1IncludeTags);
AssertHelper.AssertOnlyTagsIncluded(responseExam);
//include both
responseExam = await client.GetExamSuccesfully(link1IncludeUserAndTags);
AssertHelper.AssertUserAndTagsIncluded(responseExam);
//for private
// include none
responseExam = await client.GetExamSuccesfully(link1Private);
AssertHelper.AssertNoUserAndNoTagsIncluded(responseExam);
//include user
responseExam = await client.GetExamSuccesfully(link1PrivateIncludeUser);
AssertHelper.AssertOnlyUserIncluded(responseExam);
//include tags
responseExam = await client.GetExamSuccesfully(link1PrivateIncludeTags);
AssertHelper.AssertOnlyTagsIncluded(responseExam);
//include both
responseExam = await client.GetExamSuccesfully(link1PrivateIncludeUserAndTags);
AssertHelper.AssertUserAndTagsIncluded(responseExam);
//request user 2 exam - should not found
await client.GetNotFound(link2);
//authorize user 2
client.Authorize(loggedUser2.Token);
//request user 1 exam - should not found
await client.GetNotFound(link1);
}
public async void ShouldEditExam()
{
var client = httpClientFactory.CreateClient();
var httpCallHelper = new HttpCallHelper(client);
var dbContextHelper = new DbContextHelper(this.dbContextFactory);
var tuple = await httpCallHelper.CreateExam();
var loggedUser = tuple.Item1;
var examDto = tuple.Item3;
var putLink = $"/exams/{examDto.Id}";
var newTags = new List <string>();
newTags.Add(examDto.Tags.First().Tag);
newTags.AddRange(SampleExamContextHelper.SeededTags.Select(e => e.TagId).ToArray());
var uniqueString = Guid.NewGuid().ToGuidString();
newTags.AddRange(new string[] { $"{uniqueString}_Tag1", $"{uniqueString}_Tag2" });
var examData = new Edit.ExamData()
{
Title = $"{examDto.Title}_2",
Description = $"{examDto.Description}_2",
TimeInMinutes = examDto.TimeInMinutes + 1,
PassPercentage = examDto.PassPercentage + 1,
IsPrivate = !examDto.IsPrivate,
Tags = newTags
};
await client.PutUnauthorized(putLink, new Edit.Request()
{
Exam = examData
});
client.Authorize(loggedUser.Token);
var responseExam = await client.PutExamSuccesfully(putLink, new Edit.Request()
{
Exam = examData
});
var exam = dbContextHelper.SelectExamWitTags(examDto.Id);
var updatedAt1 = exam.UpdatedAt;
AssertHelper.AssertExam(examData, responseExam, exam);
AssertHelper.AssertExamTags(examData.Tags.ToArray(), responseExam, exam);
responseExam = await client.PutExamSuccesfully(putLink, new Edit.Request()
{
Exam = examData
});
exam = dbContextHelper.SelectExamWitTags(examDto.Id);
var updatedAt2 = exam.UpdatedAt;
AssertHelper.AssertExam(examData, responseExam, exam);
AssertHelper.AssertExamTags(examData.Tags.ToArray(), responseExam, exam);
Assert.Equal(updatedAt1, updatedAt2);
responseExam = await client.PutExamSuccesfully(putLink, new Edit.Request()
{
Exam = new Edit.ExamData()
});
exam = dbContextHelper.SelectExamWitTags(examDto.Id);
var updatedAt3 = exam.UpdatedAt;
AssertHelper.AssertExam(examData, responseExam, exam);
AssertHelper.AssertExamTags(examData.Tags.ToArray(), responseExam, exam);
Assert.Equal(updatedAt2, updatedAt3);
}
public async void ShouldGetUserExams()
{
var client = httpClientFactory.CreateClient();
var httpCallHelper = new HttpCallHelper(client);
//create 4 public user exam out of 2 are published
var tuple = await httpCallHelper.CreateExam();
var user = tuple.Item1;
await httpCallHelper.CreateExam(true, false, null, user);
await httpCallHelper.CreatePublishedExam(true, false, null, user);
await httpCallHelper.CreatePublishedExam(true, false, null, user);
//create 4 private user exam out of 2 are
await httpCallHelper.CreateExam(true, true, null, user);
await httpCallHelper.CreateExam(true, true, null, user);
await httpCallHelper.CreatePublishedExam(true, true, null, user);
await httpCallHelper.CreatePublishedExam(true, true, null, user);
var linkAll1 = "exams/user/exams";
var linkAll2 = "exams/user/exams?privateType=all&publishType=all";
var linkAllPrivates = "exams/user/exams?privateType=private";
var linkAllPublics = "exams/user/exams?privateType=public";
var linkAllPublished = "exams/user/exams?publishType=published";
var linkAllNotPublished = "exams/user/exams?publishType=notPublished";
await client.GetUnauthorized(linkAll1);
client.Authorize(user.Token);
//all
var exams = await client.GetExamsSuccesfully(linkAll1);
Assert.True(exams.Count() == 8);
//all2
exams = await client.GetExamsSuccesfully(linkAll2);
Assert.True(exams.Count() == 8);
//privates
exams = await client.GetExamsSuccesfully(linkAllPrivates);
Assert.True(exams.Count() == 4);
//publics
exams = await client.GetExamsSuccesfully(linkAllPublics);
Assert.True(exams.Count() == 4);
//published
exams = await client.GetExamsSuccesfully(linkAllPublished);
Assert.True(exams.Count() == 4);
//not published
exams = await client.GetExamsSuccesfully(linkAllNotPublished);
Assert.True(exams.Count() == 4);
//creating more user exams ...
for (int i = 0; i < 5; i++)
{
var isPrivate = i % 2 == 0;
await httpCallHelper.CreateExam(true, isPrivate, null, user);
}
//authorize after create exam unauthirized
client.Authorize(user.Token);
var limitOffsetTester = new LimitOffsetTester(client, linkAll1);
await limitOffsetTester.DoTest(GetExams);
}
public async void ShouldCreateTests()
{
var client = httpClientFactory.CreateClient();
var httpCallHelper = new HttpCallHelper(client);
var notPublishedExamItems = await httpCallHelper.CreateExam();
var user1 = notPublishedExamItems.Item1;
var examDto1 = notPublishedExamItems.Item3;
var examDto2 = (await httpCallHelper.CreateExam()).Item3;
var examDto3Published = (await httpCallHelper.CreatePublishedExam(loggedUser: user1)).Item2;
var radioQuestionData = TestData.Question.Create.NewQuestionData();
var checkboxQuestionData = TestData.Question.Create.NewQuestionData(false);
var link1 = $"/questions/{examDto1.Id}";
var link2 = $"/questions/{examDto2.Id}";
var link3Published = $"/questions/{examDto3Published.Id}";
await client.PostUnauthorized(link1, new Create.Request()
{
Question = radioQuestionData
});
client.Authorize(user1.Token);
var badQuestion = TestData.Question.Create.NewQuestionDataWithEmptyText();
await client.PostBadRequest(link1, new Create.Request()
{
Question = badQuestion
});
badQuestion = TestData.Question.Create.NewQuestionDataWithNullText();
await client.PostBadRequest(link1, new Create.Request()
{
Question = badQuestion
});
badQuestion = TestData.Question.Create.NewQuestionDataWithTooLongText();
await client.PostBadRequest(link1, new Create.Request()
{
Question = badQuestion
});
badQuestion = TestData.Question.Create.NewQuestionDataWithEmptyAnswerOption();
await client.PostBadRequest(link1, new Create.Request()
{
Question = badQuestion
});
badQuestion = TestData.Question.Create.NewQuestionDataWithNullAnswerOption();
await client.PostBadRequest(link1, new Create.Request()
{
Question = badQuestion
});
badQuestion = TestData.Question.Create.NewQuestionDataWithFewerAnswerOption();
await client.PostBadRequest(link1, new Create.Request()
{
Question = badQuestion
});
badQuestion = TestData.Question.Create.NewQuestionDataWithMoreAnswerOption();
await client.PostBadRequest(link1, new Create.Request()
{
Question = badQuestion
});
badQuestion = TestData.Question.Create.NewQuestionDataRadioWithTwoRight();
await client.PostBadRequest(link1, new Create.Request()
{
Question = badQuestion
});
badQuestion = TestData.Question.Create.NewQuestionDataCheckboxWithSingleRight();
await client.PostBadRequest(link1, new Create.Request()
{
Question = badQuestion
});
badQuestion = TestData.Question.Create.NewQuestionDataWithAllRight();
await client.PostBadRequest(link1, new Create.Request()
{
Question = badQuestion
});
badQuestion = TestData.Question.Create.NewQuestionDataWithAllWrong();
await client.PostBadRequest(link1, new Create.Request()
{
Question = badQuestion
});
badQuestion = TestData.Question.Create.NewQuestionDataWithAllRight(false);
await client.PostBadRequest(link1, new Create.Request()
{
Question = badQuestion
});
badQuestion = TestData.Question.Create.NewQuestionDataWithAllWrong(false);
await client.PostBadRequest(link1, new Create.Request()
{
Question = badQuestion
});
badQuestion = TestData.Question.Create.NewQuestionDataWithEmptyAnswerText();
await client.PostBadRequest(link1, new Create.Request()
{
Question = badQuestion
});
badQuestion = TestData.Question.Create.NewQuestionDataWithNullAnswerText();
await client.PostBadRequest(link1, new Create.Request()
{
Question = badQuestion
});
badQuestion = TestData.Question.Create.NewQuestionDataWithTooLongAnswerText();
await client.PostBadRequest(link1, new Create.Request()
{
Question = badQuestion
});
//other user's exam
await client.PostNotFound(link2, new Create.Request()
{
Question = radioQuestionData
});
//add to published exam
await client.PostNotFound(link3Published, new Create.Request()
{
Question = radioQuestionData
});
//success
await client.PostSucessfully(link1, new Create.Request()
{
Question = radioQuestionData
});
await client.PostSucessfully(link1, new Create.Request()
{
Question = checkboxQuestionData
});
}
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);
}
