public async Task ChangeStatusTo_Finished()
{
var options = Utils.GetOptions(nameof(ChangeStatusTo_Finished));
var categoryService = new Mock <ICategoryService>().Object;
var userService = new Mock <IUserService>();
var userStore = new Mock <IUserStore <User> >();
var userManager = new Mock <UserManager <User> >(userStore.Object, null, null, null,
null, null, null, null, null).Object;
var contextAccessor = new Mock <IHttpContextAccessor>().Object;
var userPrincipalFactory = new Mock <IUserClaimsPrincipalFactory <User> >().Object;
var signManager = new Mock <SignInManager <User> >(userManager, contextAccessor, userPrincipalFactory, null, null, null, null).Object;
using (var arrContext = new PhotoContestContext(options))
{
await arrContext.Contests.AddRangeAsync(Utils.SeedContests());
await arrContext.Statuses.AddRangeAsync(Utils.SeedStatuses());
await arrContext.SaveChangesAsync();
}
using (var actContext = new PhotoContestContext(options))
{
var sut = new ContestService(actContext, contextAccessor, userService.Object, categoryService, userManager, signManager);
var contest = actContext.Contests.Include(c => c.Status).First();
contest.Phase1 = DateTime.UtcNow.AddDays(-5);
contest.Phase2 = DateTime.UtcNow.AddHours(-5);
contest.Finished = DateTime.UtcNow;
await sut.ChangeStatus();
Assert.AreEqual(contest.Status.Name, "Finished");
}
}
public async Task ThrowsWhen_Phase_IsWrong()
{
var options = Utils.GetOptions(nameof(ThrowsWhen_Phase_IsWrong));
var categoryService = new Mock <ICategoryService>().Object;
var userService = new Mock <IUserService>().Object;
var userStore = new Mock <IUserStore <User> >();
var userManager = new Mock <UserManager <User> >(userStore.Object, null, null, null,
null, null, null, null, null).Object;
var contextAccessor = new Mock <IHttpContextAccessor>().Object;
var userPrincipalFactory = new Mock <IUserClaimsPrincipalFactory <User> >().Object;
var signManager = new Mock <SignInManager <User> >(userManager, contextAccessor, userPrincipalFactory, null, null, null, null).Object;
using (var arrContext = new PhotoContestContext(options))
{
await arrContext.Statuses.AddRangeAsync(Utils.SeedStatuses());
await arrContext.Categories.AddRangeAsync(Utils.SeedCategories());
await arrContext.Photos.AddRangeAsync(Utils.SeedPhotos());
await arrContext.Contests.AddRangeAsync(Utils.SeedContests());
await arrContext.SaveChangesAsync();
}
using (var actContext = new PhotoContestContext(options))
{
var sut = new ContestService(actContext, contextAccessor, userService, categoryService, userManager, signManager);
await Assert.ThrowsExceptionAsync <ArgumentException>(() => sut.GetAllOpenAsync("Wrong"));
}
}
public async Task Return_UserContests_Current()
{
var options = Utils.GetOptions(nameof(Return_UserContests_Current));
var categoryService = new Mock <ICategoryService>().Object;
var userService = new Mock <IUserService>();
var userStore = new Mock <IUserStore <User> >();
var userManager = new Mock <UserManager <User> >(userStore.Object, null, null, null,
null, null, null, null, null);
var contextAccessor = new Mock <IHttpContextAccessor>();
var userPrincipalFactory = new Mock <IUserClaimsPrincipalFactory <User> >().Object;
var signManager = new Mock <SignInManager <User> >(userManager.Object, contextAccessor.Object, userPrincipalFactory, null, null, null, null).Object;
var context = new Mock <HttpContext>();
contextAccessor.Setup(a => a.HttpContext).Returns(context.Object);
using (var arrContext = new PhotoContestContext(options))
{
await arrContext.Users.AddRangeAsync(Utils.SeedUsers());
await arrContext.Statuses.AddRangeAsync(Utils.SeedStatuses());
await arrContext.Categories.AddRangeAsync(Utils.SeedCategories());
await arrContext.Photos.AddRangeAsync(Utils.SeedPhotos());
await arrContext.Contests.AddRangeAsync(Utils.SeedContests());
await arrContext.UserContests.AddRangeAsync(Utils.SeedUserContests());
await arrContext.Ranks.AddRangeAsync(Utils.SeedRanks());
await arrContext.SaveChangesAsync();
var user = arrContext.Users.Skip(4).First();
userManager.Setup(u => u.GetUserName(signManager.Context.User)).Returns(user.UserName);
userService.Setup(u => u.GetUserByUsernameAsync(It.IsAny <string>())).Returns(Task.FromResult(user));
}
using (var actContext = new PhotoContestContext(options))
{
var contestToEnroll = actContext.Contests.Last();
var user = actContext.Users.Skip(4).First();
var allUserContests = actContext.UserContests.Where(uc => uc.UserId == user.Id);
var allUserContestsDTO = new List <ContestDTO>();
foreach (var userContest in allUserContests)
{
var contest = await actContext.Contests
.Include(c => c.Category)
.Include(c => c.Status)
.FirstAsync(c => c.Id == userContest.ContestId && c.IsDeleted == false);
allUserContestsDTO.Add(new ContestDTO(contest));
}
var sut = new ContestService(actContext, contextAccessor.Object, userService.Object, categoryService, userManager.Object, signManager);
var result = await sut.GetByUserAsync("current");
Assert.AreEqual(result.Count(), allUserContestsDTO.Where(c => c.Status != "Finished").Count());
Assert.AreEqual(string.Join(",", allUserContestsDTO.Where(c => c.Status != "Finished")), string.Join(",", result));
}
}
public async Task Return_True_IfDeleted()
{
var options = Utils.GetOptions(nameof(Return_True_IfDeleted));
var categoryService = new Mock <ICategoryService>().Object;
var userService = new Mock <IUserService>().Object;
var userStore = new Mock <IUserStore <User> >();
var userManager = new Mock <UserManager <User> >(userStore.Object, null, null, null,
null, null, null, null, null).Object;
var contextAccessor = new Mock <IHttpContextAccessor>().Object;
var userPrincipalFactory = new Mock <IUserClaimsPrincipalFactory <User> >().Object;
var signManager = new Mock <SignInManager <User> >(userManager, contextAccessor, userPrincipalFactory, null, null, null, null).Object;
using (var arrContext = new PhotoContestContext(options))
{
await arrContext.Statuses.AddRangeAsync(Utils.SeedStatuses());
await arrContext.Categories.AddRangeAsync(Utils.SeedCategories());
await arrContext.Contests.AddRangeAsync(Utils.SeedContests());
await arrContext.SaveChangesAsync();
}
using (var actContext = new PhotoContestContext(options))
{
var sut = new ContestService(actContext, contextAccessor, userService, categoryService, userManager, signManager);
var result = await sut.DeleteAsync(actContext.Contests.First().Name);
Assert.IsTrue(actContext.Contests.First().IsDeleted);
}
}
public void TestInitialize()
{
AutoMapperConfig.Execute();
this.mocksContainer = new MocksContainer();
this.mocksContainer.SetupMocks();
var requestMock = new Mock <HttpRequestBase>();
requestMock.SetupGet(x => x.Headers).Returns(
new System.Net.WebHeaderCollection {
{ "X-Requested-With", "XMLHttpRequest" }
});
var responseMock = new Mock <HttpResponseBase>();
var contextMock = new Mock <HttpContextBase>();
contextMock.SetupGet(c => c.Request).Returns(requestMock.Object);
contextMock.SetupGet(c => c.User.Identity.IsAuthenticated).Returns(true);
contextMock.SetupGet(c => c.User.Identity.Name).Returns("admin");
contextMock.Setup(c => c.Response).Returns(responseMock.Object);
var dataMock = new Mock <IPhotoContestData>();
dataMock.Setup(d => d.Contests).Returns(this.mocksContainer.ContestsRepositoryMock.Object);
var service = new ContestService(dataMock.Object);
var controller = new ContestsController(dataMock.Object, service);
controller.ControllerContext = new ControllerContext(contextMock.Object, new RouteData(), controller);
this.fakeContestsController = controller;
}
public async Task Return_AllOpenContests()
{
var options = Utils.GetOptions(nameof(Return_AllOpenContests));
var categoryService = new Mock <ICategoryService>().Object;
var userService = new Mock <IUserService>().Object;
var userStore = new Mock <IUserStore <User> >();
var userManager = new Mock <UserManager <User> >(userStore.Object, null, null, null,
null, null, null, null, null).Object;
var contextAccessor = new Mock <IHttpContextAccessor>().Object;
var userPrincipalFactory = new Mock <IUserClaimsPrincipalFactory <User> >().Object;
var signManager = new Mock <SignInManager <User> >(userManager, contextAccessor, userPrincipalFactory, null, null, null, null).Object;
using (var arrContext = new PhotoContestContext(options))
{
await arrContext.Statuses.AddRangeAsync(Utils.SeedStatuses());
await arrContext.Categories.AddRangeAsync(Utils.SeedCategories());
await arrContext.Photos.AddRangeAsync(Utils.SeedPhotos());
await arrContext.Contests.AddRangeAsync(Utils.SeedContests());
await arrContext.SaveChangesAsync();
}
using (var actContext = new PhotoContestContext(options))
{
var sut = new ContestService(actContext, contextAccessor, userService, categoryService, userManager, signManager);
var result = await sut.AllOpenViewAsync();
Assert.AreEqual(actContext.Contests.Where(c => c.IsOpen == true).Count(), result.Count());
Assert.AreEqual(string.Join(",", actContext.Contests.Where(c => c.IsOpen == true).Select(c => new ContestDTO(c))), string.Join(",", result));
}
}
public async Task ThrowWhen_User_AlreadyEnrolledApi()
{
var options = Utils.GetOptions(nameof(ThrowWhen_User_AlreadyEnrolledApi));
var categoryService = new Mock <ICategoryService>().Object;
var userService = new Mock <IUserService>();
var userStore = new Mock <IUserStore <User> >();
var userManager = new Mock <UserManager <User> >(userStore.Object, null, null, null,
null, null, null, null, null);
var contextAccessor = new Mock <IHttpContextAccessor>();
var userPrincipalFactory = new Mock <IUserClaimsPrincipalFactory <User> >().Object;
var signManager = new Mock <SignInManager <User> >(userManager.Object, contextAccessor.Object, userPrincipalFactory, null, null, null, null).Object;
var context = new Mock <HttpContext>();
contextAccessor.Setup(a => a.HttpContext).Returns(context.Object);
using (var arrContext = new PhotoContestContext(options))
{
await arrContext.Users.AddRangeAsync(Utils.SeedUsers());
await arrContext.Statuses.AddRangeAsync(Utils.SeedStatuses());
await arrContext.Categories.AddRangeAsync(Utils.SeedCategories());
await arrContext.Photos.AddRangeAsync(Utils.SeedPhotos());
await arrContext.Contests.AddRangeAsync(Utils.SeedContests());
await arrContext.UserContests.AddRangeAsync(Utils.SeedUserContests());
await arrContext.Ranks.AddRangeAsync(Utils.SeedRanks());
await arrContext.Juries.AddRangeAsync(Utils.SeedJuries());
await arrContext.SaveChangesAsync();
var userToEnroll = arrContext.Users.Skip(2).First();
var claims = new List <Claim>()
{
new Claim(ClaimTypes.NameIdentifier, userToEnroll.UserName.ToString()),
};
var identity = new ClaimsIdentity(claims);
var claimsPrincipal = new ClaimsPrincipal(identity);
contextAccessor.Setup(x => x.HttpContext.User).Returns(claimsPrincipal);
userService.Setup(x => x.GetUserByUsernameAsync(It.IsAny <string>())).Returns(Task.FromResult(userToEnroll));
}
using (var actContext = new PhotoContestContext(options))
{
var contestToEnroll = actContext.Contests.First();
var userToEnroll = actContext.Users.Skip(2).First();
var sut = new ContestService(actContext, contextAccessor.Object, userService.Object, categoryService, userManager.Object, signManager);
await Assert.ThrowsExceptionAsync <ArgumentException>(() => sut.EnrollApiAsync(contestToEnroll.Name));
}
}
public async Task Return_UserContestsApi()
{
var options = Utils.GetOptions(nameof(Return_UserContestsApi));
var categoryService = new Mock <ICategoryService>().Object;
var userService = new Mock <IUserService>();
var userStore = new Mock <IUserStore <User> >();
var userManager = new Mock <UserManager <User> >(userStore.Object, null, null, null,
null, null, null, null, null);
var contextAccessor = new Mock <IHttpContextAccessor>();
var userPrincipalFactory = new Mock <IUserClaimsPrincipalFactory <User> >().Object;
var signManager = new Mock <SignInManager <User> >(userManager.Object, contextAccessor.Object, userPrincipalFactory, null, null, null, null).Object;
var context = new Mock <HttpContext>();
contextAccessor.Setup(a => a.HttpContext).Returns(context.Object);
using (var arrContext = new PhotoContestContext(options))
{
await arrContext.Users.AddRangeAsync(Utils.SeedUsers());
await arrContext.Statuses.AddRangeAsync(Utils.SeedStatuses());
await arrContext.Categories.AddRangeAsync(Utils.SeedCategories());
await arrContext.Photos.AddRangeAsync(Utils.SeedPhotos());
await arrContext.Contests.AddRangeAsync(Utils.SeedContests());
await arrContext.UserContests.AddRangeAsync(Utils.SeedUserContests());
await arrContext.Ranks.AddRangeAsync(Utils.SeedRanks());
await arrContext.SaveChangesAsync();
var userToEnroll = arrContext.Users.Skip(2).First();
var claims = new List <Claim>()
{
new Claim(ClaimTypes.NameIdentifier, userToEnroll.UserName.ToString()),
};
var identity = new ClaimsIdentity(claims);
var claimsPrincipal = new ClaimsPrincipal(identity);
contextAccessor.Setup(x => x.HttpContext.User).Returns(claimsPrincipal);
userService.Setup(x => x.GetUserByUsernameAsync(It.IsAny <string>())).Returns(Task.FromResult(userToEnroll));
}
using (var actContext = new PhotoContestContext(options))
{
var userContests = actContext.UserContests.Include(uc => uc.Contest).Where(uc => uc.UserId == actContext.Users.Skip(2).First().Id);
var contests = userContests.Select(uc => uc.Contest);
var sut = new ContestService(actContext, contextAccessor.Object, userService.Object, categoryService, userManager.Object, signManager);
var result = await sut.GetUserContestsApiAsync();
Assert.AreEqual(result.Count(), userContests.Count());
}
}
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 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 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 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 ThrowWhen_User_IsJury()
{
var options = Utils.GetOptions(nameof(ThrowWhen_User_IsJury));
var categoryService = new Mock <ICategoryService>().Object;
var userService = new Mock <IUserService>();
var userStore = new Mock <IUserStore <User> >();
var userManager = new Mock <UserManager <User> >(userStore.Object, null, null, null,
null, null, null, null, null).Object;
var contextAccessor = new Mock <IHttpContextAccessor>().Object;
var userPrincipalFactory = new Mock <IUserClaimsPrincipalFactory <User> >().Object;
var signManager = new Mock <SignInManager <User> >(userManager, contextAccessor, userPrincipalFactory, null, null, null, null).Object;
using (var arrContext = new PhotoContestContext(options))
{
await arrContext.Users.AddRangeAsync(Utils.SeedUsers());
await arrContext.Statuses.AddRangeAsync(Utils.SeedStatuses());
await arrContext.Categories.AddRangeAsync(Utils.SeedCategories());
await arrContext.Photos.AddRangeAsync(Utils.SeedPhotos());
await arrContext.Contests.AddRangeAsync(Utils.SeedContests());
await arrContext.UserContests.AddRangeAsync(Utils.SeedUserContests());
await arrContext.Ranks.AddRangeAsync(Utils.SeedRanks());
await arrContext.Juries.AddRangeAsync(Utils.SeedJuries());
await arrContext.SaveChangesAsync();
arrContext.Contests.First().IsOpen = false;
await arrContext.SaveChangesAsync();
var userToInvite = arrContext.Users.Skip(8).First();
userService.Setup(u => u.GetUserByUsernameAsync(It.IsAny <string>())).Returns(Task.FromResult(userToInvite));
}
using (var actContext = new PhotoContestContext(options))
{
var userToInvite = actContext.Users.Skip(8).First().UserName;
var sut = new ContestService(actContext, contextAccessor, userService.Object, categoryService, userManager, signManager);
await Assert.ThrowsExceptionAsync <ArgumentException>(() =>
sut.InviteAsync(actContext.Contests.Last().Name, userToInvite));
}
}
/// <summary>
///
/// </summary>
/// <param name="id">contest id</param>
/// <returns></returns>
public IActionResult List(int id)
{
var submissionsToSee =
this.submissions.All <ListSubmissionModel>().Where(s => s.UserEmail == this.User.Name);
IContestService contests = new ContestService();
var allContests = contests
.All <Contest>()
.Select(c => new { Name = c.Name, Id = c.Id })
.Where(c => c.Id == id); //could use automapper here too
StringBuilder contestsHtml = new StringBuilder();
//draw contest html
foreach (var cont in allContests)
{
var state = string.Empty;
if (id == cont.Id)
{
state = "active";
}
contestsHtml.Append(string.Format(this.ContestLink, state));
}
this.ViewModel["contests"] = contestsHtml.ToString();
var currentUserEmail = this.User.Name;
IUserService users = new UserService();
var userSubmissions = this.submissions
.All <Submission>()
.Count(s => s.ContestId == id &&
s.UserId == users.GetId(currentUserEmail));
StringBuilder submissionsHtml = new StringBuilder();
//draw contest submissions html
for (int i = 0; i < userSubmissions; i++)
{
Random r = new Random();
var color = r.Next(0, 100) < 70 ? "danger" : "success";
submissionsHtml.Append(string.Format(this.ContestSubmission, color));
}
this.ViewModel["submissions"] = submissionsHtml.ToString();
return(View());
}
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 GetAllTest()
{
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 count = service.GetContestsCount();
var allContests = service.GetAllContests <ContestViewModel>();
Assert.True(count == allContests.Count(), "GetAllTest method does not work correctly");
}
public async Task Return_UpdatedContest()
{
var options = Utils.GetOptions(nameof(Return_UpdatedContest));
var updateContestDTO = new Mock <UpdateContestDTO>().Object;
updateContestDTO.Name = "UpdateTest";
updateContestDTO.CategoryName = "Cars";
updateContestDTO.IsOpen = true;
updateContestDTO.Phase1 = DateTime.Now.AddHours(2).ToString("dd.MM.yy HH:mm");
updateContestDTO.Phase2 = DateTime.Now.AddHours(30).ToString("dd.MM.yy HH:mm");
updateContestDTO.Finished = DateTime.Now.AddHours(32).ToString("dd.MM.yy HH:mm");
var categoryService = new Mock <ICategoryService>();
var userService = new Mock <IUserService>().Object;
var userStore = new Mock <IUserStore <User> >();
var userManager = new Mock <UserManager <User> >(userStore.Object, null, null, null,
null, null, null, null, null).Object;
var contextAccessor = new Mock <IHttpContextAccessor>().Object;
var userPrincipalFactory = new Mock <IUserClaimsPrincipalFactory <User> >().Object;
var signManager = new Mock <SignInManager <User> >(userManager, contextAccessor, userPrincipalFactory, null, null, null, null).Object;
using (var arrContext = new PhotoContestContext(options))
{
await arrContext.Categories.AddRangeAsync(Utils.SeedCategories());
await arrContext.Statuses.AddRangeAsync(Utils.SeedStatuses());
await arrContext.Contests.AddRangeAsync(Utils.SeedContests());
await arrContext.SaveChangesAsync();
categoryService.Setup(c => c.FindCategoryByNameAsync(It.IsAny <string>())).Returns(Task.FromResult(arrContext.Categories.First()));
}
using (var actContext = new PhotoContestContext(options))
{
var sut = new ContestService(actContext, contextAccessor, userService, categoryService.Object, userManager, signManager);
var result = await sut.UpdateAsync(actContext.Contests.First().Name, updateContestDTO);
Assert.AreEqual(updateContestDTO.Name, result.Name);
Assert.AreEqual(updateContestDTO.Phase1, result.Phase1);
Assert.AreEqual(updateContestDTO.Phase2, result.Phase2);
Assert.AreEqual(updateContestDTO.Finished, result.Finished);
Assert.AreEqual(updateContestDTO.CategoryName, result.Category);
}
}
public async Task HasContestWithIdTest()
{
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 contestId = context.Contests.FirstOrDefault().Id;
var currentContest = service.HasContestWithId(contestId);
Assert.True(currentContest != null, "HasContestWithIdTest method does not work correctly");
}
public async Task GetContestDetails()
{
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 contestId = context.Contests.FirstOrDefault().Id;
var contestDetails = service.GetContestDetails <ContestViewModel>(contestId);
Assert.True(contestDetails != null, "GetContestDetails method does not work correctly");
}
public async Task ReturnTrue_IfUser_ChosenSuccessfully()
{
var options = Utils.GetOptions(nameof(ReturnTrue_IfUser_ChosenSuccessfully));
var categoryService = new Mock <ICategoryService>().Object;
var userService = new Mock <IUserService>();
var userStore = new Mock <IUserStore <User> >();
var userManager = new Mock <UserManager <User> >(userStore.Object, null, null, null,
null, null, null, null, null).Object;
var contextAccessor = new Mock <IHttpContextAccessor>().Object;
var userPrincipalFactory = new Mock <IUserClaimsPrincipalFactory <User> >().Object;
var signManager = new Mock <SignInManager <User> >(userManager, contextAccessor, userPrincipalFactory, null, null, null, null).Object;
using (var arrContext = new PhotoContestContext(options))
{
await arrContext.Users.AddRangeAsync(Utils.SeedUsers());
await arrContext.Statuses.AddRangeAsync(Utils.SeedStatuses());
await arrContext.Categories.AddRangeAsync(Utils.SeedCategories());
await arrContext.Photos.AddRangeAsync(Utils.SeedPhotos());
await arrContext.Contests.AddRangeAsync(Utils.SeedContests());
await arrContext.UserContests.AddRangeAsync(Utils.SeedUserContests());
await arrContext.Ranks.AddRangeAsync(Utils.SeedRanks());
await arrContext.SaveChangesAsync();
var userToChoose = arrContext.Users.Skip(8).First();
userService.Setup(u => u.GetUserByUsernameAsync(It.IsAny <string>())).Returns(Task.FromResult(userToChoose));
}
using (var actContext = new PhotoContestContext(options))
{
var userToChoose = actContext.Users.Skip(8).First().UserName;
var sut = new ContestService(actContext, contextAccessor, userService.Object, categoryService, userManager, signManager);
var result = await sut.ChooseJuryAsync(actContext.Contests.First().Name, userToChoose);
Assert.IsTrue(result);
}
}
public async Task ThrowsWhen_Contest_NotFound()
{
var options = Utils.GetOptions(nameof(ThrowsWhen_Contest_NotFound));
var categoryService = new Mock <ICategoryService>().Object;
var userService = new Mock <IUserService>().Object;
var userStore = new Mock <IUserStore <User> >();
var userManager = new Mock <UserManager <User> >(userStore.Object, null, null, null,
null, null, null, null, null).Object;
var contextAccessor = new Mock <IHttpContextAccessor>().Object;
var userPrincipalFactory = new Mock <IUserClaimsPrincipalFactory <User> >().Object;
var signManager = new Mock <SignInManager <User> >(userManager, contextAccessor, userPrincipalFactory, null, null, null, null).Object;
using (var actContext = new PhotoContestContext(options))
{
var sut = new ContestService(actContext, contextAccessor, userService, categoryService, userManager, signManager);
await Assert.ThrowsExceptionAsync <ArgumentException>(() => sut.FindContestByNameAsync("wrong"));
}
}
public async Task CountTest()
{
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 countBefore = service.GetContestsCount();
await service.AddContestAsync(DateTime.Now, DateTime.Now, "Legion2", "Legion", context.Categories.First().Id);
var countAfter = service.GetContestsCount();
Assert.True(countAfter == countBefore + 1, "Count method does not work correctly");
}
public async Task UpdateContestAsyncTest()
{
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 contestId = context.Contests.FirstOrDefault().Id;
var contestCategory = context.Contests.FirstOrDefault().CategoryId;
await service.UpdateContestAsync(DateTime.Now, DateTime.Now, "*", "*", contestCategory, contestId);
var contestAfterName = service.GetContestName(contestId);
Assert.True(contestAfterName == "*", "HasContesNow method does not work correctly");
}
public async Task ThrowWhen_Phase2Date_IsWrong()
{
var options = Utils.GetOptions(nameof(ThrowWhen_Phase2Date_IsWrong));
var updateContestDTO = new Mock <UpdateContestDTO>().Object;
updateContestDTO.Name = "UpdateTest";
updateContestDTO.CategoryName = "Cars";
updateContestDTO.IsOpen = true;
updateContestDTO.Phase1 = DateTime.Now.AddHours(2).ToString("dd.MM.yy HH:mm");
updateContestDTO.Phase2 = "02.06.21 20:00";
updateContestDTO.Finished = DateTime.Now.AddHours(32).ToString("dd.MM.yy HH:mm");
var categoryService = new Mock <ICategoryService>();
var userService = new Mock <IUserService>().Object;
var userStore = new Mock <IUserStore <User> >();
var userManager = new Mock <UserManager <User> >(userStore.Object, null, null, null,
null, null, null, null, null).Object;
var contextAccessor = new Mock <IHttpContextAccessor>().Object;
var userPrincipalFactory = new Mock <IUserClaimsPrincipalFactory <User> >().Object;
var signManager = new Mock <SignInManager <User> >(userManager, contextAccessor, userPrincipalFactory, null, null, null, null).Object;
using (var arrContext = new PhotoContestContext(options))
{
await arrContext.Categories.AddRangeAsync(Utils.SeedCategories());
await arrContext.Statuses.AddRangeAsync(Utils.SeedStatuses());
await arrContext.Contests.AddRangeAsync(Utils.SeedContests());
await arrContext.SaveChangesAsync();
categoryService.Setup(c => c.FindCategoryByNameAsync(It.IsAny <string>())).Returns(Task.FromResult(arrContext.Categories.First()));
}
using (var actContext = new PhotoContestContext(options))
{
var sut = new ContestService(actContext, contextAccessor, userService, categoryService.Object, userManager, signManager);
await Assert.ThrowsExceptionAsync <ArgumentException>(() => sut.UpdateAsync(actContext.Contests.First().Name, updateContestDTO));
}
}
public async Task ThrowsWhen_Phase1_NotCorrect()
{
var options = Utils.GetOptions(nameof(ThrowsWhen_Phase1_NotCorrect));
var newContestDTO = new Mock <NewContestDTO>().Object;
newContestDTO.Name = "NewestTest";
newContestDTO.CategoryName = "Cars";
newContestDTO.IsOpen = true;
newContestDTO.Phase1 = "01.01.21 20:00";
newContestDTO.Phase2 = DateTime.Now.AddHours(30).ToString("dd.MM.yy HH:mm");
newContestDTO.Finished = DateTime.Now.AddHours(32).ToString("dd.MM.yy HH:mm");
var categoryService = new Mock <ICategoryService>();
var userService = new Mock <IUserService>().Object;
var userStore = new Mock <IUserStore <User> >();
var userManager = new Mock <UserManager <User> >(userStore.Object, null, null, null,
null, null, null, null, null).Object;
var contextAccessor = new Mock <IHttpContextAccessor>().Object;
var userPrincipalFactory = new Mock <IUserClaimsPrincipalFactory <User> >().Object;
var signManager = new Mock <SignInManager <User> >(userManager, contextAccessor, userPrincipalFactory, null, null, null, null).Object;
var category = new Category();
category.Name = "Cars";
categoryService.Setup(c => c.FindCategoryByNameAsync(newContestDTO.CategoryName)).Returns(Task.FromResult(category));
using (var arrContext = new PhotoContestContext(options))
{
await arrContext.Categories.AddAsync(category);
await arrContext.Statuses.AddRangeAsync(Utils.SeedStatuses());
await arrContext.SaveChangesAsync();
}
using (var actContext = new PhotoContestContext(options))
{
var sut = new ContestService(actContext, contextAccessor, userService, categoryService.Object, userManager, signManager);
await Assert.ThrowsExceptionAsync <ArgumentException>(() => sut.CreateAsync(newContestDTO));
}
}
public RegisterPlayerVm(IPerson personToUpdate = null)
{
Player = personToUpdate;
if (Player != null)
{
Title = "Modifier un joueur";
LastName = Player.LastName;
FirstName = Player.FirstName;
Alias = Player.Alias;
Mail = Player.Mail;
CanMailing = Player.CanMailing;
IsMemberOfAssociation = Player.IsMember;
}
else
{
Title = "Enregister un joueur";
}
Save = new RelayCommand(
delegate
{
var contestService = new ContestService();
if (Player == null)
{
contestService.CreatePerson(LastName, FirstName, Alias, Mail, CanMailing, IsMemberOfAssociation);
}
else
{
contestService.UpdatePerson(Player, LastName, FirstName, Alias, Mail, CanMailing, IsMemberOfAssociation);
}
},
delegate
{
return(!string.IsNullOrEmpty(Alias));
});
}
public ContestCreateVm()
{
// Do MEF resolution to inject dependencies.
FlippingContainer.Instance.ComposeParts(this);
//Default values.
CountMinPlayerByTeam = 1;
CountMaxPlayerByTeam = 3;
CountField = 2;
Date = DateTime.Now;
Create = new RelayCommand(
delegate
{
var command = new CreateContestCmd
{
Date = Date,
StreetNumber = 0,
Street = Street,
ZipCode = ZipCode,
City = City,
Indoor = Indoor,
CountField = CountField,
CountMinPlayerByTeam = CountMinPlayerByTeam,
CountMaxPlayerByTeam = CountMaxPlayerByTeam
};
var service = new ContestService();
var newContest = service.Create(command);
CloseCommand.Execute(newContest);
},
delegate
{
return(true);
});
}
public ContestsController()
{
ContestService = new ContestService(new ContestRepo(), new ShowContestRepo());
}
public ScoreCriteriaController()
{
ScoreCriterionService = new ScoreCriterionService(new ScoreCriterionRepo(), new ContestScoreCriterionRepo());
ContestService = new ContestService(new ContestRepo(), new ShowContestRepo());
}
public void Setup()
{
this.dbContext = Substitute.For <IPipeBandGamesContext>();
this.service = new ContestService(dbContext);
}
