public async Task GetAllReviewedEssayFromTecherInRangeTest()
{
var context = EssayCompetitionContextInMemoryFactory.InitializeContext();
var essay1 = await this.seeder.SeedGradedEssayAsync(context);
var essay2 = await this.seeder.SeedGradedEssayAsync(context);
await this.seeder.AddGradeAsync(context, essay1.Id);
await this.seeder.AddGradeAsync(context, essay2.Id);
var user1 = await this.seeder.SeedUserAsync(context, "*****@*****.**");
var essayTeacher1 = await this.seeder.SeedEssayTeacher(context, user1.Id, essay1.Id);
var essayTeacher2 = await this.seeder.SeedEssayTeacher(context, user1.Id, essay2.Id);
var essayRepository = new EfDeletableEntityRepository <Essay>(context);
var categoryRepository = new EfDeletableEntityRepository <Category>(context);
var gradeRepository = new EfRepository <Grade>(context);
var essayTeacherRepository = new EfDeletableEntityRepository <EssayTeacher>(context);
var service = new TeacherReviewedService(essayRepository, categoryRepository, gradeRepository, essayTeacherRepository);
var result = service.GetAllReviewedEssayFromTecherInRange <EssayViewModel>(user1.Id, 1, 2);
Assert.True(result.Count() == 2, "GetAllReviewedEssayFromTecherInRange method does not work correctly");
}
public async Task GetEssaysFromUserWithIdInRangeTest()
{
var context = EssayCompetitionContextInMemoryFactory.InitializeContext();
var userId = await this.seeder.SeedUserManyEssaysAsync(context, 4);
var essayRepository = new EfDeletableEntityRepository <Essay>(context);
var service = new EssayService(essayRepository);
var resultedEssays = service.GetEssaysFromUserWithIdInRange <EssayViewModel>(userId, CurrentPage, PageSize);
Assert.True(resultedEssays.Count() == (context.Essays.Count() - PageSize), "GetEssaysFromUserWithIdInRange method does not work correctly");
}
public async Task GetEssayDetailsTest()
{
var context = EssayCompetitionContextInMemoryFactory.InitializeContext();
var essay = await this.seeder.SeedEssayAsync(context);
var essayRepository = new EfDeletableEntityRepository <Essay>(context);
var service = new EssayService(essayRepository);
var resultedEssay = service.GetEssayDetails <EssayViewModel>(essay.Id);
Assert.True(essay.UserId == resultedEssay.UserId, "GetEssayDetails method does not work correctly");
}
public async Task HasAnyGradedEssayTest()
{
var context = EssayCompetitionContextInMemoryFactory.InitializeContext();
var seededEssay = await this.seeder.SeedEssayAsync(context);
var essayRepository = new EfDeletableEntityRepository <Essay>(context);
var service = new EssayService(essayRepository);
var result = service.HasAnyGradedEssay();
Assert.True(result == false, "HasAnyGradedEssay method does not work correctly");
}
public async Task GetEssayNameTest()
{
var context = EssayCompetitionContextInMemoryFactory.InitializeContext();
var seededEssay = await this.seeder.SeedEssayAsync(context);
var essayRepository = new EfDeletableEntityRepository <Essay>(context);
var service = new EssayService(essayRepository);
var resultedName = service.GetEssayName(seededEssay.UserId, seededEssay.ContestId);
Assert.True(resultedName == seededEssay.Title, "GetEssayName method does not work correctly");
}
public async Task EssayGradedWithoutGrade()
{
var context = EssayCompetitionContextInMemoryFactory.InitializeContext();
var essay = await this.seeder.SeedEssayAsync(context);
var gradeRepository = new EfRepository <Grade>(context);
var service = new GradeService(gradeRepository);
var result = service.EssayGradet(essay.Id);
Assert.True(result == false, "EssayGraded method does not work correctly");
}
public async Task HasUserAdditionalInfoWithIdShouldReturnFalse()
{
var context = EssayCompetitionContextInMemoryFactory.InitializeContext();
var user = await this.seeder.SeedUserAsync(context, "*****@*****.**");
var userAdditionalInfoRepository = new EfDeletableEntityRepository <UserAdditionalInfo>(context);
var service = new UserAdditionalInfoService(userAdditionalInfoRepository);
var result = service.HasUserAdditionalInfoWithId(user.Id);
Assert.False(result, "HasUserAdditionalInfoWithId method does not work correctly");
}
public async Task GetEssayCountTest()
{
var context = EssayCompetitionContextInMemoryFactory.InitializeContext();
var expectedCount = 4;
var userId = await this.seeder.SeedUserManyEssaysAsync(context, expectedCount);
var essayRepository = new EfDeletableEntityRepository <Essay>(context);
var service = new EssayService(essayRepository);
var resultedCount = service.GetEssaysCount();
Assert.True(resultedCount == expectedCount, "GetEssayCount method does not work correctly");
}
public async Task HasDeletedUserWithIdTest()
{
var context = EssayCompetitionContextInMemoryFactory.InitializeContext();
var user = await this.seeder.SeedDeletedUserAsync(context, "*****@*****.**");
var roleRepository = new EfDeletableEntityRepository <ApplicationRole>(context);
var userRepository = new EfDeletableEntityRepository <ApplicationUser>(context);
var service = new UsersService(userRepository, roleRepository);
var result = service.HasDeletedUserWithId(user.Id);
Assert.True(result, "HasDeletedUserWithId method does not work correctly");
}
public async Task GetNextContestIdTest()
{
var context = EssayCompetitionContextInMemoryFactory.InitializeContext();
var futureContest = await this.seeder.SeedFutureContestAsync(context);
var contestantContestRepository = new EfDeletableEntityRepository <ContestantContest>(context);
var contestRepository = new EfDeletableEntityRepository <Contest>(context);
var service = new SignService(contestantContestRepository, contestRepository);
var reusltedId = service.GetNextContestId();
Assert.True(reusltedId == futureContest.Id, "GetNextContestId method does not work correctly");
}
public async Task HasRoleWithIdTest()
{
var context = EssayCompetitionContextInMemoryFactory.InitializeContext();
var roleName1 = "Ninja1";
var role = await this.seeder.SeedRoleAsync(context, roleName1);
var roleRepository = new EfDeletableEntityRepository <ApplicationRole>(context);
var service = new RolesService(roleRepository);
var result = service.HasRoleWithId(role.Id);
Assert.True(result == true, "HasRoleWithId method does not work correctly");
}
public async Task UserAlreadyRegisteredForCompetitionTest()
{
var context = EssayCompetitionContextInMemoryFactory.InitializeContext();
var contestantContest = await this.seeder.SeedContestantContestAsync(context);
var contestantContestRepository = new EfDeletableEntityRepository <ContestantContest>(context);
var contestRepository = new EfDeletableEntityRepository <Contest>(context);
var service = new SignService(contestantContestRepository, contestRepository);
var result = service.UserAlreadyRegisteredForCompetition(contestantContest.ContestantId, contestantContest.ContestId);
Assert.True(result == true, "UserAlreadyRegisteredForCompetition method does not work correctly");
}
public async Task GetCommentsFromEssayTest()
{
var context = EssayCompetitionContextInMemoryFactory.InitializeContext();
var essay = await this.seeder.SeedEssayAsync(context);
var comment = await this.seeder.AddCommentToEssay(context, "testComment", essay.Id);
var commentRepository = new EfDeletableEntityRepository <Comment>(context);
var service = new CommentService(commentRepository);
var resultedComment = service.GetCommentsFromEssay <CommentViewModel>(comment.EssayId);
Assert.True(resultedComment.First().Content == comment.Content, "GetEssayDetails method does not work correctly");
}
public async Task HasWithId()
{
var context = EssayCompetitionContextInMemoryFactory.InitializeContext();
await this.SeedData(context);
var repository = new EfDeletableEntityRepository <Category>(context);
var service = new CategoryService(repository);
var firstId = service.GetFirstOrDefaultCategoryId();
var hasWithId = await service.HasWithIdAsync(firstId);
Assert.True(hasWithId == true, "GetWithId method does not work correctly");
}
public async Task GetEssayPointsTest()
{
var context = EssayCompetitionContextInMemoryFactory.InitializeContext();
var essay = await this.seeder.SeedEssayAsync(context);
var grade = await this.seeder.AddGradeAsync(context, essay.Id);
var gradeRepository = new EfRepository <Grade>(context);
var service = new GradeService(gradeRepository);
var resultedPoints = service.GetEssayPoints(essay.Id);
Assert.True(resultedPoints == grade.Points, "GetEssayPoints method does not work correctly");
}
public async Task GetUserWithIdAdditionalInfoTest()
{
var context = EssayCompetitionContextInMemoryFactory.InitializeContext();
var user = await this.seeder.SeedUserAsync(context, "*****@*****.**");
var userAdditionalInfo = await this.seeder.SeedUserAdditionalInfo(context, user.Id, "#");
var userAdditionalInfoRepository = new EfDeletableEntityRepository <UserAdditionalInfo>(context);
var service = new UserAdditionalInfoService(userAdditionalInfoRepository);
var result = service.GetUserWithIdAdditionalInfo <IndexViewModel>(user.Id);
Assert.True(result.UserId == user.Id, "GetUserWithIdAdditionalInfo method does not work correctly");
}
public async Task NextContextTest()
{
var context = EssayCompetitionContextInMemoryFactory.InitializeContext();
var contestRetId = await this.SeedNextContest(context);
var contestRepository = new EfDeletableEntityRepository <Contest>(context);
var essayRepository = new EfDeletableEntityRepository <Essay>(context);
var essayTeacherRepository = new EfDeletableEntityRepository <EssayTeacher>(context);
var contestantContestRepository = new EfDeletableEntityRepository <ContestantContest>(context);
var service = new ContestService(contestRepository, essayRepository, essayTeacherRepository, contestantContestRepository);
var result = service.NextContext <ContestViewModel>();
Assert.True(contestRetId == result.Id, "NextContextTest method does not work correctly");
}
public async Task GetContestParticipantsCount()
{
var context = EssayCompetitionContextInMemoryFactory.InitializeContext();
var seedContestanContest = await this.SeedContestContestant(context);
var contestRepository = new EfDeletableEntityRepository <Contest>(context);
var essayRepository = new EfDeletableEntityRepository <Essay>(context);
var essayTeacherRepository = new EfDeletableEntityRepository <EssayTeacher>(context);
var contestantContestRepository = new EfDeletableEntityRepository <ContestantContest>(context);
var service = new ContestService(contestRepository, essayRepository, essayTeacherRepository, contestantContestRepository);
var participantsCount = service.GetContestParticipantsCount(seedContestanContest.First().Contest.Id);
Assert.True(participantsCount == seedContestanContest.Count(), "GetContestParticipantsCount method does not work correctly");
}
public async Task GetContestNameTest()
{
var context = EssayCompetitionContextInMemoryFactory.InitializeContext();
await this.seeder.SeedContestAsync(context);
var contestantContestRepository = new EfDeletableEntityRepository <ContestantContest>(context);
var contestRepository = new EfDeletableEntityRepository <Contest>(context);
var service = new SignService(contestantContestRepository, contestRepository);
var currentContext = context.Contests.First();
var reusltedName = service.GetContestName(currentContext.Id);
Assert.True(currentContext.Name == reusltedName, "GetContestName method does not work correctly");
}
public async Task HasEssayWithIdTest()
{
var context = EssayCompetitionContextInMemoryFactory.InitializeContext();
var essay = await this.seeder.SeedEssayAsync(context);
var essayRepository = new EfDeletableEntityRepository <Essay>(context);
var categoryRepository = new EfDeletableEntityRepository <Category>(context);
var gradeRepository = new EfRepository <Grade>(context);
var essayTeacherRepository = new EfDeletableEntityRepository <EssayTeacher>(context);
var service = new TeacherReviewedService(essayRepository, categoryRepository, gradeRepository, essayTeacherRepository);
var result = service.HasEssayWithId(essay.Id);
Assert.True(result == true, "HasEssayWithId method does not work correctly");
}
public async Task GetEssayInfoTest()
{
var context = EssayCompetitionContextInMemoryFactory.InitializeContext();
var essay = await this.seeder.SeedEssayAsync(context);
var essayRepository = new EfDeletableEntityRepository <Essay>(context);
var categoryRepository = new EfDeletableEntityRepository <Category>(context);
var gradeRepository = new EfRepository <Grade>(context);
var essayTeacherRepository = new EfDeletableEntityRepository <EssayTeacher>(context);
var service = new TeacherReviewedService(essayRepository, categoryRepository, gradeRepository, essayTeacherRepository);
var essayInfo = service.GetEssayInfo <EssayViewModel>(essay.Id);
Assert.True(essay.Id == essayInfo.Id, "GetEssayInfo method does not work correctly");
}
public async Task IsUserAlreadySubmitedEssay()
{
var context = EssayCompetitionContextInMemoryFactory.InitializeContext();
var seededEssay = await this.SeedSubmitedEssay(context);
var contestRepository = new EfDeletableEntityRepository <Contest>(context);
var essayRepository = new EfDeletableEntityRepository <Essay>(context);
var essayTeacherRepository = new EfDeletableEntityRepository <EssayTeacher>(context);
var contestantContestRepository = new EfDeletableEntityRepository <ContestantContest>(context);
var service = new ContestService(contestRepository, essayRepository, essayTeacherRepository, contestantContestRepository);
var userSubmited = service.IsUserAlreadySubmitedEssay(seededEssay.UserId);
Assert.True(userSubmited == true, "IsUserAlreadySubmitedEssay method does not work correctly");
}
public async Task GetUserByIdTest()
{
var context = EssayCompetitionContextInMemoryFactory.InitializeContext();
var user1 = await this.seeder.SeedDeletedUserAsync(context, "*****@*****.**");
var user2 = await this.seeder.SeedDeletedUserAsync(context, "*****@*****.**");
var roleRepository = new EfDeletableEntityRepository <ApplicationRole>(context);
var userRepository = new EfDeletableEntityRepository <ApplicationUser>(context);
var service = new UsersService(userRepository, roleRepository);
var result = service.GetUserById <DetailsViewModel>(user1.Id);
Assert.True(result.Id == user1.Id, "GetUserById method does not work correctly");
}
public async Task GradeEssayAsyncTest()
{
var context = EssayCompetitionContextInMemoryFactory.InitializeContext();
var essay = await this.seeder.SeedEssayAsync(context);
var essayRepository = new EfDeletableEntityRepository <Essay>(context);
var categoryRepository = new EfDeletableEntityRepository <Category>(context);
var gradeRepository = new EfRepository <Grade>(context);
var essayTeacherRepository = new EfDeletableEntityRepository <EssayTeacher>(context);
var service = new TeacherService(essayRepository, categoryRepository, gradeRepository, essayTeacherRepository);
await service.GradeEssayAsync("stava", 12, essay.Id);
Assert.True(context.Grades.First(x => x.EssayId == essay.Id).Points == 12, "GradeEssayAsync method does not work correctly");
}
public async Task GetAll()
{
var context = EssayCompetitionContextInMemoryFactory.InitializeContext();
await this.SeedData(context);
var repository = new EfDeletableEntityRepository <Category>(context);
var service = new CategoryService(repository);
var countBefore = service.GetCount();
var allCategories = service.GetAll <CategoryViewModel>();
var countAfter = allCategories.Count();
Assert.True(countBefore == countAfter, "GetAll method does not work correctly");
}
public async Task GetContestIdTest()
{
var context = EssayCompetitionContextInMemoryFactory.InitializeContext();
var seededContest = await this.SeedContestAsync(context);
var contestRepository = new EfDeletableEntityRepository <Contest>(context);
var essayRepository = new EfDeletableEntityRepository <Essay>(context);
var essayTeacherRepository = new EfDeletableEntityRepository <EssayTeacher>(context);
var contestantContestRepository = new EfDeletableEntityRepository <ContestantContest>(context);
var service = new ContestService(contestRepository, essayRepository, essayTeacherRepository, contestantContestRepository);
var resultId = service.GetContestId(seededContest.Name);
Assert.True(seededContest.Id == resultId, "GetContestIdTest method does not work correctly");
}
public async Task CreateRoleAsyncTest()
{
var context = EssayCompetitionContextInMemoryFactory.InitializeContext();
var roleName = "Ninja";
var roleViewModel = new CreateViewModel()
{
Name = roleName
};
var roleRepository = new EfDeletableEntityRepository <ApplicationRole>(context);
var service = new RolesService(roleRepository);
await service.CreateRoleAsync <CreateViewModel>(roleViewModel.ToQueryable());
Assert.True(roleRepository.All().Any(x => x.Name == roleName), "CreateRoleAsync method does not work correctly");
}
public async Task GetContestNowId()
{
var context = EssayCompetitionContextInMemoryFactory.InitializeContext();
await this.SeedData(context);
var contestRepository = new EfDeletableEntityRepository <Contest>(context);
var essayRepository = new EfDeletableEntityRepository <Essay>(context);
var essayTeacherRepository = new EfDeletableEntityRepository <EssayTeacher>(context);
var contestantContestRepository = new EfDeletableEntityRepository <ContestantContest>(context);
var service = new ContestService(contestRepository, essayRepository, essayTeacherRepository, contestantContestRepository);
var contestNow = service.HasContextNow(DateTime.Now);
Assert.True(contestNow == true, "GetContestNowId method does not work correctly");
}
public async Task GetCalendarInfoTest()
{
var context = EssayCompetitionContextInMemoryFactory.InitializeContext();
await this.seeder.SeedContestAsync(context);
await this.seeder.SeedContestAsync(context);
var contestRepository = new EfDeletableEntityRepository <Contest>(context);
var service = new CalendarService(contestRepository);
var expectedEventsCount = 2;
var result = service.GetCalendarInfo(DateTime.Now.Month, DateTime.Now.Year);
Assert.True(result.Events.Count() == expectedEventsCount, "GetCalendarInfo method does not work correctly");
}
public async Task AddCategory()
{
var context = EssayCompetitionContextInMemoryFactory.InitializeContext();
await this.SeedData(context);
var repository = new EfDeletableEntityRepository <Category>(context);
var service = new CategoryService(repository);
var initialCount = service.GetCount();
await service.CreateAsync("test", "test", "#");
var count = service.GetCount();
Assert.True(count == initialCount + 1, "Create method does not work correctly");
}
