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()
});
}
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 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 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 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 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 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 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 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 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);
}