public ActionResult SkillResult(Skill skill)
{
SkillsService proxy = new SkillsService();
proxy.createSkill(skill.name);
return(View());
}
public ActionResult EmployeeResult(Employee employee)
{
SkillsService proxy = new SkillsService();
proxy.createEmployee(employee.name);
return(View());
}
public JsonResult ReadResult(string name)
{
SkillsService proxy = new SkillsService();
var parents = proxy.read(name);
return(Json(parents, JsonRequestBehavior.AllowGet));
}
public ActionResult ProjectResult(Project project)
{
SkillsService proxy = new SkillsService();
proxy.createProject(project.name);
return(View());
}
public void TestsTakeAndDeleteUser()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString());
var repository =
new EfDeletableEntityRepository <ApplicationUser>(new ApplicationDbContext(options.Options));
var studentEfRepository =
new EfRepository <StudentJob>(new ApplicationDbContext(options.Options));
var userSkillRepository =
new EfRepository <UsersSkill>(new ApplicationDbContext(options.Options));
var jobRepository =
new EfDeletableEntityRepository <Job>(new ApplicationDbContext(options.Options));
var jobService = new JobsService(jobRepository, studentEfRepository);
var skillRepository =
new EfDeletableEntityRepository <Skill>(new ApplicationDbContext(options.Options));
var skillService = new SkillsService(skillRepository, userSkillRepository);
var usersService = new ApplicationUsersService(repository, jobService, studentEfRepository, jobRepository,
skillService, userSkillRepository, skillRepository);
var user = new ApplicationUser
{
Description = "test",
Type = UserType.Employer,
};
repository.AddAsync(user).GetAwaiter().GetResult();
repository.SaveChangesAsync().GetAwaiter().GetResult();
AutoMapperConfig.RegisterMappings(typeof(CompaniesServiceTests.MyTest).Assembly);
usersService.DeleteAsync(user.Id).GetAwaiter().GetResult();
Assert.Empty(repository.All());
repository.Delete(user);
repository.SaveChangesAsync().GetAwaiter().GetResult();
}
public ActionResult UpdateResult(string name, string parent)
{
SkillsService proxy = new SkillsService();
proxy.update(name, parent);
return(View());
}
public async Task UpdateAsyncCorrectlyUpdatesInformation()
{
AutoMapperInitializer.InitializeMapper();
var context = InMemoryDbContextInitializer.InitializeContext();
await context.Skills.AddRangeAsync(this.SeedData());
await context.SaveChangesAsync();
var repository = new EfDeletableEntityRepository <Skill>(context);
var service = new SkillsService(repository);
var model = new EditViewModel
{
Name = "NewName",
IsDeleted = true,
};
var result = await service.UpdateAsync(1, model);
Assert.NotEqual(-1, result);
var dbRecord = await context.Skills.FindAsync(1);
Assert.NotEqual("First", dbRecord.Name);
Assert.NotNull(dbRecord.DeletedOn);
Assert.True(dbRecord.IsDeleted);
}
public void TestAddExistUserinSkill()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString());
var repository =
new EfDeletableEntityRepository <ApplicationUser>(new ApplicationDbContext(options.Options));
var studentEfRepository =
new EfRepository <StudentJob>(new ApplicationDbContext(options.Options));
var userSkillRepository =
new EfRepository <UsersSkill>(new ApplicationDbContext(options.Options));
var jobRepository =
new EfDeletableEntityRepository <Job>(new ApplicationDbContext(options.Options));
var jobService = new JobsService(jobRepository, studentEfRepository);
var skillRepository =
new EfDeletableEntityRepository <Skill>(new ApplicationDbContext(options.Options));
var skillService = new SkillsService(skillRepository, userSkillRepository);
var usersService = new ApplicationUsersService(repository, jobService, studentEfRepository, jobRepository, skillService, userSkillRepository, skillRepository);
var user = new ApplicationUser
{
Description = "test",
Type = UserType.Student,
};
var skill = new Skill
{
Name = "test",
};
skillRepository.AddAsync(skill).GetAwaiter().GetResult();
skillRepository.SaveChangesAsync().GetAwaiter().GetResult();
repository.AddAsync(user).GetAwaiter().GetResult();
repository.SaveChangesAsync().GetAwaiter().GetResult();
AutoMapperConfig.RegisterMappings(typeof(CompaniesServiceTests.MyTest).Assembly);
Assert.Throws <ArgumentException>(() => usersService.AddSkillAsync(skill.Id, user.Id).GetAwaiter().GetResult());
}
public void TestGetCompaniesCount()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString());
var repository =
new EfDeletableEntityRepository <ApplicationUser>(new ApplicationDbContext(options.Options));
var studentEfRepository =
new EfRepository <StudentJob>(new ApplicationDbContext(options.Options));
var userSkillRepository =
new EfRepository <UsersSkill>(new ApplicationDbContext(options.Options));
var jobRepository =
new EfDeletableEntityRepository <Job>(new ApplicationDbContext(options.Options));
var jobService = new JobsService(jobRepository, studentEfRepository);
var skillRepository =
new EfDeletableEntityRepository <Skill>(new ApplicationDbContext(options.Options));
var skillService = new SkillsService(skillRepository, userSkillRepository);
var usersService = new ApplicationUsersService(repository, jobService, studentEfRepository, jobRepository, skillService, userSkillRepository, skillRepository);
AutoMapperConfig.RegisterMappings(typeof(CompaniesServiceTests.MyTest).Assembly);
var user = new ApplicationUser
{
FullName = "IvanIvanov",
Email = "test@test",
Type = UserType.Employer,
};
repository.AddAsync(user);
repository.SaveChangesAsync();
Assert.Equal(1, usersService.GetCompaniesCount());
repository.Delete(user);
repository.SaveChangesAsync();
}
public void IndexTest()
{
_projectRepository.Setup(service => service.GetAll(It.IsAny <Expression <Func <Project, bool> > >(), null, null)).Returns(this.projects);
var projectService = new ProjectsService(_projectRepository.Object, _interestedInProjectRepository.Object, _applicationUserRepository.Object, _userSkillRepository.Object, _skillRepository.Object);
var skillsService = new SkillsService(_skillRepository.Object, _projectSkillRepository.Object, _userSkillRepository.Object);
var postsController = new PostsController(projectService, skillsService);
postsController.ControllerContext = this.controllerContext;
var result = postsController.Index("");
var viewResult = Assert.IsType <ViewResult>(result);
Assert.IsAssignableFrom <List <Project> >(viewResult.ViewData.Model);
_projectRepository.Reset();
_projectRepository.Setup(service => service.GetAll(It.IsAny <Expression <Func <Project, bool> > >(), null, It.IsAny <String>())).Returns(this.projects);
_skillRepository.Setup(service => service.Get(1)).Returns(this.skills[0]);
projectService = new ProjectsService(_projectRepository.Object, _interestedInProjectRepository.Object, _applicationUserRepository.Object, _userSkillRepository.Object, _skillRepository.Object);
skillsService = new SkillsService(_skillRepository.Object, _projectSkillRepository.Object, _userSkillRepository.Object);
postsController = new PostsController(projectService, skillsService);
postsController.ControllerContext = this.controllerContext;
result = postsController.Index("Java");
viewResult = Assert.IsType <ViewResult>(result);
Assert.IsAssignableFrom <List <Project> >(viewResult.ViewData.Model);
_projectRepository.Reset();
_skillRepository.Reset();
}
public void AddNewSkillTest()
{
_skillRepository.Setup(repo => repo.Insert(It.IsAny <Skill>())).Returns((EntityEntry <Skill>)FormatterServices.GetUninitializedObject(typeof(EntityEntry <Skill>)));
_skillRepository.Setup(repo => repo.Save()).Returns(1);
var projectService = new ProjectsService(_projectRepository.Object, _interestedInProjectRepository.Object, _applicationUserRepository.Object, _userSkillRepository.Object, _skillRepository.Object);
var skillsService = new SkillsService(_skillRepository.Object, _projectSkillRepository.Object, _userSkillRepository.Object);
var postsController = new PostsController(projectService, skillsService);
postsController.ControllerContext = this.controllerContext;
var result = postsController.AddNewSkill(new Skill());
var viewResult = Assert.IsType <RedirectToActionResult>(result);
Assert.Null(viewResult.ControllerName);
Assert.Equal("Post", viewResult.ActionName);
_skillRepository.Reset();
_skillRepository.Setup(repo => repo.Insert(It.IsAny <Skill>())).Returns((EntityEntry <Skill>)FormatterServices.GetUninitializedObject(typeof(EntityEntry <Skill>)));
_skillRepository.Setup(repo => repo.Save()).Returns(0);
projectService = new ProjectsService(_projectRepository.Object, _interestedInProjectRepository.Object, _applicationUserRepository.Object, _userSkillRepository.Object, _skillRepository.Object);
skillsService = new SkillsService(_skillRepository.Object, _projectSkillRepository.Object, _userSkillRepository.Object);
postsController = new PostsController(projectService, skillsService);
postsController.ControllerContext = this.controllerContext;
Assert.Throws <Exception>(() => postsController.AddNewSkill(new Skill()));
_skillRepository.Reset();
}
public HelpService(SkillsService skillsService,
SpecialService specialService,
InteractiveService interactiveService)
{
_skillsService = skillsService;
_interactiveService = interactiveService;
}
public ActionResult DeleteResult(string name)
{
SkillsService proxy = new SkillsService();
proxy.delete(name);
return(View());
}
public SkillServiceTest()
{
this._skillRepository = new MockSkillRepository();
this._projectSkillRepository = new MockProjectSkillRepository();
this._userSkillRepository = new MockUserSkillRepository();
this.Seed();
this._skillService = new SkillsService(_skillRepository, _projectSkillRepository, _userSkillRepository);
}
public CharacterSkillsModule(
CharacterService charService,
SkillsService skillsService,
HelpService helpService)
{
_charService = charService;
_skillsService = skillsService;
_helpService = helpService;
}
public void Setup()
{
_logger = A.Fake <ILogger>();
_skillsRepo = A.Fake <ISkillsRepo>();
_svcAutoMapper = A.Fake <ISvcAutoMapper>();
_skillTotalCalculator = A.Fake <ISkillTotalCalculator>();
_primaryStatsService = A.Fake <IPrimaryStatsService>();
_skillsService = new SkillsService(_logger, _skillsRepo, _svcAutoMapper, _skillTotalCalculator, _primaryStatsService);
}
public AdminModule(CharacterService charService,
SkillsService skillsService,
SpecialService specialService,
HelpService helpService)
{
_charService = charService;
_skillsService = skillsService;
_specialService = specialService;
_helpService = helpService;
}
public void GetSkillIndex_returns_zero_if_programmer_has_no_skills()
{
var id = "id";
var networkRepository = Substitute.For <INetworkRepository>();
networkRepository.GetById(id).Returns(new Programmer(id, null, new string[] { }));
var skillsService = new SkillsService(networkRepository);
var skillIndex = skillsService.GetSkillIndex(id, "skill");
Assert.That(skillIndex, Is.EqualTo(0));
}
public void GetSkills_calls_ProgrammerRepository_with_given_id(string expectedSkills)
{
var id = "programmer id";
var programmerRepository = Substitute.For <INetworkRepository>();
programmerRepository.GetById(id).Returns(new Programmer(id, null, new[] { expectedSkills }));
var skillsService = new SkillsService(programmerRepository);
var skills = skillsService.GetSkills(id);
Assert.That(skills, Is.EqualTo(new[] { expectedSkills }));
}
public void GetSkillIndex_returns_one_based_index_of_given_skill()
{
var id = "id";
var networkRepository = Substitute.For <INetworkRepository>();
networkRepository.GetById(id).Returns(new Programmer(id, null, new[] { "other skill", "skill" }));
var skillsService = new SkillsService(networkRepository);
var skillIndex = skillsService.GetSkillIndex(id, "skill");
Assert.That(skillIndex, Is.EqualTo(2));
}
public void GetSkillRank_returns_zero_if_programmer_does_not_have_given_skill()
{
var id = "id";
var networkRepository = Substitute.For <INetworkRepository>();
networkRepository.GetById(id).Returns(new Programmer(id, null, new [] { "other skill" }));
var skillsService = new SkillsService(networkRepository);
var skillRank = skillsService.GetSkillIndex(id, "skill");
Assert.That(skillRank, Is.EqualTo(0));
}
public async Task DeleteFailsWhenIdNotInDatabase()
{
AutoMapperInitializer.InitializeMapper();
var context = InMemoryDbContextInitializer.InitializeContext();
var repository = new EfDeletableEntityRepository <Skill>(context);
var service = new SkillsService(repository);
var result = await service.DeleteAsync(100);
Assert.False(result);
}
public void GetSkillsTest()
{
//Arrange
SkillsService service = new SkillsService(_unitOfWork.Object);
//Act
var result = service.GetSkills();
//Assert
Assert.That(result.Count, Is.EqualTo(2));
Assert.That(result[1].Name, Is.EqualTo("Databases"));
Assert.That(result[1].Skills[1].Name, Is.EqualTo("Oracle"));
}
public AdminModule(CharacterService charService,
ExperienceService experienceService,
SkillsService skillsService,
SpecialService specialService,
StatisticsService statService,
HelpService helpService)
{
_charService = charService;
_experienceService = experienceService;
_skillsService = skillsService;
_specialService = specialService;
_statService = statService;
_helpService = helpService;
}
public async Task GetAllReturnsCorrectNumberOfRecords()
{
AutoMapperInitializer.InitializeMapper();
var context = InMemoryDbContextInitializer.InitializeContext();
await context.Skills.AddRangeAsync(this.SeedData());
await context.SaveChangesAsync();
var repository = new EfDeletableEntityRepository <Skill>(context);
var service = new SkillsService(repository);
var result = service.GetAll <EditViewModel>();
Assert.Equal(2, result.Count());
}
protected override IProNet LoadProNet(string filename)
{
// load your implementation here
var fileService = new FileService();
var networkValidator = new NetworkValidator();
var networkService = new NetworkRepository(fileService, filename, networkValidator);
var rankService = new RankService(networkService);
var skillsService = new SkillsService(networkService);
var separationService = new SeparationService(networkService);
var recommendationService = new RecommendationService(networkService);
var teamStrengthService = new TeamStrengthService(separationService, skillsService, rankService);
var permutationService = new PermutationService();
var strongestTeamService = new StrongestTeamService(networkService, teamStrengthService, permutationService);
return(new ProNet(rankService, skillsService, separationService, recommendationService, teamStrengthService, strongestTeamService));
}
public async Task UpdateAsyncFailsWhenIdNotInDb()
{
AutoMapperInitializer.InitializeMapper();
var context = InMemoryDbContextInitializer.InitializeContext();
var repository = new EfDeletableEntityRepository <Skill>(context);
var service = new SkillsService(repository);
var model = new EditViewModel
{
Name = "NewName",
IsDeleted = true,
};
var result = await service.UpdateAsync(100, model);
Assert.Equal(-1, result);
}
public async Task GetDetailsReturnsCorrectInformation()
{
AutoMapperInitializer.InitializeMapper();
var context = InMemoryDbContextInitializer.InitializeContext();
await context.Skills.AddRangeAsync(this.SeedData());
await context.SaveChangesAsync();
var repository = new EfDeletableEntityRepository <Skill>(context);
var service = new SkillsService(repository);
var result = service.GetDetails <EditViewModel>(1);
Assert.NotNull(result);
Assert.Equal(1, result.Id);
Assert.Equal("First", result.Name);
Assert.False(result.IsDeleted);
}
public void DeleteSkill()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString());
var repository =
new EfDeletableEntityRepository <ApplicationUser>(new ApplicationDbContext(options.Options));
var studentEfRepository =
new EfRepository <StudentJob>(new ApplicationDbContext(options.Options));
var userSkillRepository =
new EfRepository <UsersSkill>(new ApplicationDbContext(options.Options));
var jobRepository =
new EfDeletableEntityRepository <Job>(new ApplicationDbContext(options.Options));
var jobService = new JobsService(jobRepository, studentEfRepository);
var skillRepository =
new EfDeletableEntityRepository <Skill>(new ApplicationDbContext(options.Options));
var skillService = new SkillsService(skillRepository, userSkillRepository);
var usersService = new ApplicationUsersService(repository, jobService, studentEfRepository, jobRepository, skillService, userSkillRepository, skillRepository);
var user = new ApplicationUser
{
FullName = "Gosho"
};
var skill = new Skill
{
Name = "C#",
};
var userSkill = new UsersSkill
{
SkillId = skill.Id,
ApplicationUserId = user.Id,
};
repository.AddAsync(user).GetAwaiter().GetResult();
repository.SaveChangesAsync().GetAwaiter().GetResult();
skillRepository.AddAsync(skill).GetAwaiter().GetResult();
skillRepository.SaveChangesAsync().GetAwaiter().GetResult();
userSkillRepository.AddAsync(userSkill).GetAwaiter().GetResult();
userSkillRepository.SaveChangesAsync();
userSkillRepository.Delete(userSkill);
skillService.DeleteAsync(skill.Id, user.Id).GetAwaiter().GetResult();
Assert.Equal(1, skillRepository.All().Count());
}
public async Task CreateSuccessfullyAddsNewSkill()
{
AutoMapperInitializer.InitializeMapper();
var context = InMemoryDbContextInitializer.InitializeContext();
var repository = new EfDeletableEntityRepository <Skill>(context);
var service = new SkillsService(repository);
var model = new CreateViewModel
{
Name = "New Skill",
IsDeleted = true,
};
int id = await service.CreateAsync(model);
Assert.NotEqual(-1, id);
Assert.Equal(1, context.Skills.IgnoreQueryFilters().Count());
}
