public async Task UpdateAsync_WithValidModel_WorksCorrectly() { // Arrange const string expectedResult = "TestJobTitle"; var context = new JobFinderDbContext(new DbContextOptionsBuilder <JobFinderDbContext>() .UseInMemoryDatabase(Guid.NewGuid().ToString()) .Options); var model = new Job() { Location = "Test Location", Description = "Random description", EndDate = DateTime.UtcNow, Company = new Company() { CompanyName = "Test Company", User = new User() { UserName = "******" }, }, Category = new Category() { CategoryType = "NewCategory" }, JobType = new JobType() { Type = "NewType" } }; await context.AddAsync(model); context.SaveChanges(); var jobService = new JobService(new EfRepository <Company>(context), new EfRepository <Job>(context), new EfRepository <JobCandidate>(context), new EfRepository <User>(context), new EfRepository <JobSeeker>(context)); var serviceModel = new JobServiceModel { Id = model.Id, Title = expectedResult, Location = model.Location, Description = model.Description, EndDate = model.EndDate }; var result = await jobService.UpdateAsync(serviceModel); Assert.True(result); var actualResult = (await context.Jobs.SingleAsync(j => j.Id == model.Id)).Title; Assert.Equal(expectedResult, actualResult); }
public async Task DeleteAsync_WithExistentResume_ReturnsTrue() { var context = new JobFinderDbContext(new DbContextOptionsBuilder <JobFinderDbContext>() .UseInMemoryDatabase(Guid.NewGuid().ToString()) .Options); var model = new Resume() { JobSeeker = new JobSeeker() { FirstName = "JobSeekerFirstName", LastName = "JobSeekerFirstName", User = new User() { UserName = "******" } } }; await context.AddAsync(model); context.SaveChanges(); var resumeService = new ResumeService(new EfRepository <JobSeeker>(context), new EfRepository <Resume>(context), new EfRepository <User>(context)); var result = await resumeService.DeleteAsync(model.Id); var dbModels = await context.Resumes.AnyAsync(); Assert.True(result); Assert.False(dbModels); }
public async Task AddResume_ToUser_WithOne_ReturnsFalse() { string testUsername = "******"; var context = new JobFinderDbContext(new DbContextOptionsBuilder <JobFinderDbContext>() .UseInMemoryDatabase(Guid.NewGuid().ToString()) .Options); var model = new Resume() { JobSeeker = new JobSeeker() { FirstName = "JobSeekerFirstName", LastName = "JobSeekerFirstName", User = new User() { UserName = "******" } } }; await context.AddAsync(model); context.SaveChanges(); var resumeService = new ResumeService(new EfRepository <JobSeeker>(context), new EfRepository <Resume>(context), new EfRepository <User>(context)); var result = await resumeService.AddResumeToJobSeeker(testUsername); Assert.False(result); }
public async Task AddSkill_WithInvalidData_ToExistingResume_ReturnsFalse() { var context = new JobFinderDbContext(new DbContextOptionsBuilder <JobFinderDbContext>() .UseInMemoryDatabase(Guid.NewGuid().ToString()) .Options); var model = new Resume() { JobSeeker = new JobSeeker() { FirstName = "JobSeekerName1", LastName = "JobSeekerName2", User = new User() { UserName = "******" } } }; await context.AddAsync(model); context.SaveChanges(); var serviceModel = new SkillServiceModel(); var skillService = new SkillService(new EfRepository <Resume>(context), new EfRepository <Skill>(context)); var result = await skillService.AddSkill(model.Id, serviceModel); Assert.False(result); }
public async Task RemoveExistingSkill_ReturnsTrue() { var context = new JobFinderDbContext(new DbContextOptionsBuilder <JobFinderDbContext>() .UseInMemoryDatabase(Guid.NewGuid().ToString()) .Options); var model = new Skill() { Name = "Skill1", Resume = new Resume() }; await context.AddAsync(model); context.SaveChanges(); var skillService = new SkillService(new EfRepository <Resume>(context), new EfRepository <Skill>(context)); var result = await skillService.RemoveSkill(model.Id); Assert.True(result); var dbModels = await context.Skills.AnyAsync(); Assert.False(dbModels); }
public async Task UpdateAsync_WithInvalidData_ReturnsTrue() { string expectedResult = "Skill1"; var context = new JobFinderDbContext(new DbContextOptionsBuilder <JobFinderDbContext>() .UseInMemoryDatabase(Guid.NewGuid().ToString()) .Options); var model = new Skill() { Name = expectedResult, Resume = new Resume() }; await context.AddAsync(model); context.SaveChanges(); var serviceModel = new SkillServiceModel() { Id = model.Id, }; var skillService = new SkillService(new EfRepository <Resume>(context), new EfRepository <Skill>(context)); var result = await skillService.UpdateAsync(serviceModel); Assert.False(result); var actualResult = (await context.Skills.SingleAsync(s => s.Id == model.Id)).Name; Assert.Equal(expectedResult, actualResult); }
public async Task GetByIdAsync_WorksCorrectly() { string expectedResult = "MajorTest"; var context = new JobFinderDbContext(new DbContextOptionsBuilder <JobFinderDbContext>() .UseInMemoryDatabase(Guid.NewGuid().ToString()) .Options); var model = new Education() { Major = expectedResult, Institute = "InstituteTest", From = 2000, To = 2001, Resume = new Resume() }; await context.AddAsync(model); context.SaveChanges(); var educationsService = new EducationsService(new EfRepository <Education>(context), new EfRepository <Resume>(context)); var result = await educationsService.GetByIdAsync(model.Id); Assert.Equal(expectedResult, result.Major); }
public async Task RemoveExistingEducation_ReturnsTrue() { var context = new JobFinderDbContext(new DbContextOptionsBuilder <JobFinderDbContext>() .UseInMemoryDatabase(Guid.NewGuid().ToString()) .Options); var model = new Education() { Major = "MajorTest", Institute = "InstituteTest", From = 2000, To = 2001, }; await context.AddAsync(model); context.SaveChanges(); var educationsService = new EducationsService(new EfRepository <Education>(context), new EfRepository <Resume>(context)); var result = await educationsService.RemoveEducationById(model.Id); Assert.True(result); var dbModels = await context.EducationsHistory.AnyAsync(); Assert.False(dbModels); }
public async Task RemoveExistingWorkExperience_ReturnsTrue() { var context = new JobFinderDbContext(new DbContextOptionsBuilder <JobFinderDbContext>() .UseInMemoryDatabase(Guid.NewGuid().ToString()) .Options); var model = new WorkExperience() { Position = "PositionTest", Institute = "InstituteTest", From = 2000, To = 2001, }; await context.AddAsync(model); context.SaveChanges(); var workService = new WorkHistoryService(new EfRepository <Resume>(context), new EfRepository <WorkExperience>(context)); var result = await workService.RemoveWorkExperience(model.Id); Assert.True(result); var dbModels = await context.WorksHistory.AnyAsync(); Assert.False(dbModels); }
public async Task GetAllActive_WithDeadlineSmallerThanActualDate_WorksCorrectly() { var context = new JobFinderDbContext(new DbContextOptionsBuilder <JobFinderDbContext>() .UseInMemoryDatabase(Guid.NewGuid().ToString()) .Options); var randomJobTitleNames = new[] { "Job1", "Job2", "Job3" } .OrderBy(j => j) .ToArray(); var expectedCountResult = 0; foreach (var jobTitle in randomJobTitleNames) { var model = new Job() { Title = jobTitle, Location = "Test Location", Description = "Random description", EndDate = DateTime.UtcNow.AddDays(-1), Company = new Company() { CompanyName = "Test Company", User = new User() { UserName = "******" }, }, Category = new Category() { CategoryType = "NewCategory" }, JobType = new JobType() { Type = "NewType" } }; await context.AddAsync(model); } context.SaveChanges(); var jobService = new JobService(new EfRepository <Company>(context), new EfRepository <Job>(context), new EfRepository <JobCandidate>(context), new EfRepository <User>(context), new EfRepository <JobSeeker>(context)); var actualResults = (await jobService.GetAllActive()) .Select(j => j.Title) .OrderBy(j => j) .ToArray(); Assert.Equal(expectedCountResult, actualResults.Count()); }
public async Task GetAllForResume_WithData_WorksCorrectly() { var context = new JobFinderDbContext(new DbContextOptionsBuilder <JobFinderDbContext>() .UseInMemoryDatabase(Guid.NewGuid().ToString()) .Options); var expectedResults = new[] { "Major1", "Major2", "Major3" } .OrderBy(c => c) .ToArray(); var model = new Resume() { EducationHistory = new List <Education>() { new Education() { Major = expectedResults[0], Institute = "InstituteTest", From = 2000, To = 2001, }, new Education() { Major = expectedResults[1], Institute = "InstituteTest", From = 2000, To = 2001, }, new Education() { Major = expectedResults[2], Institute = "InstituteTest", From = 2000, To = 2001, }, } }; await context.AddAsync(model); context.SaveChanges(); var educationsService = new EducationsService(new EfRepository <Education>(context), new EfRepository <Resume>(context)); var actualResults = (await educationsService.GetAllForResume(model.Id)) .Select(e => e.Major) .OrderBy(e => e) .ToArray(); Assert.Equal(expectedResults, actualResults); }
public async Task GetAllForResume_WithData_WorksCorrectly() { var context = new JobFinderDbContext(new DbContextOptionsBuilder <JobFinderDbContext>() .UseInMemoryDatabase(Guid.NewGuid().ToString()) .Options); var expectedResults = new[] { "Position1", "Position2", "Position3" } .OrderBy(c => c) .ToArray(); var model = new Resume() { WorkHistory = new List <WorkExperience>() { new WorkExperience() { Position = expectedResults[0], Institute = "InstituteTest", From = 2000, To = 2001, }, new WorkExperience() { Position = expectedResults[1], Institute = "InstituteTest", From = 2000, To = 2001, }, new WorkExperience() { Position = expectedResults[2], Institute = "InstituteTest", From = 2000, To = 2001, }, } }; await context.AddAsync(model); context.SaveChanges(); var workService = new WorkHistoryService(new EfRepository <Resume>(context), new EfRepository <WorkExperience>(context)); var actualResults = (await workService.GetAllForResume(model.Id)) .Select(w => w.Position) .OrderBy(w => w) .ToArray(); Assert.Equal(expectedResults, actualResults); }
public async Task CreateAsync_WithValidModel_WorksCorrectly() { var context = new JobFinderDbContext(new DbContextOptionsBuilder <JobFinderDbContext>() .UseInMemoryDatabase(Guid.NewGuid().ToString()) .Options); var companyModel = new Company() { CompanyName = "Test Company Name", User = new User() { UserName = "******" } }; await context.AddAsync(companyModel); context.SaveChanges(); var serviceModel = new JobServiceModel() { Title = "Test title", Location = "Test Location", Description = "Random description", EndDate = DateTime.UtcNow, Company = new CompanyServiceModel() { User = new UserServiceModel() { UserName = companyModel.User.UserName }, } }; var jobService = new JobService(new EfRepository <Company>(context), new EfRepository <Job>(context), new EfRepository <JobCandidate>(context), new EfRepository <User>(context), new EfRepository <JobSeeker>(context)); var result = await jobService.CreateAsync(serviceModel); var dbModel = context.Jobs.SingleOrDefault(); Assert.NotNull(dbModel); Assert.Equal(result, dbModel.Id); }
public async Task CreateAsync_WithInvalidModel_ReturnsFalse() { var context = new JobFinderDbContext(new DbContextOptionsBuilder <JobFinderDbContext>() .UseInMemoryDatabase(Guid.NewGuid().ToString()) .Options); var companyModel = new Company() { CompanyName = "Test Company Name", User = new User() { UserName = "******" } }; await context.AddAsync(companyModel); context.SaveChanges(); var serviceModel = new JobServiceModel() { Location = "Test Location", Description = "Random description", EndDate = DateTime.UtcNow, Company = new CompanyServiceModel() { User = new UserServiceModel() { UserName = companyModel.User.UserName }, } }; var jobService = new JobService(new EfRepository <Company>(context), new EfRepository <Job>(context), new EfRepository <JobCandidate>(context), new EfRepository <User>(context), new EfRepository <JobSeeker>(context)); var result = await jobService.CreateAsync(serviceModel); Assert.Null(result); var dbModel = await context.JobSeekers.AnyAsync(); Assert.False(dbModel); }
public async Task DeleteAsync_WithExistingJob_ReturnsTrue() { var context = new JobFinderDbContext(new DbContextOptionsBuilder <JobFinderDbContext>() .UseInMemoryDatabase(Guid.NewGuid().ToString()) .Options); var model = new Job() { Location = "Test Location", Description = "Random description", EndDate = DateTime.UtcNow, Company = new Company() { CompanyName = "Test Company", User = new User() { UserName = "******" }, }, Category = new Category() { CategoryType = "NewCategory" }, JobType = new JobType() { Type = "NewType" } }; await context.AddAsync(model); context.SaveChanges(); var jobService = new JobService(new EfRepository <Company>(context), new EfRepository <Job>(context), new EfRepository <JobCandidate>(context), new EfRepository <User>(context), new EfRepository <JobSeeker>(context)); var result = await jobService.DeleteAsync(model.Id); Assert.True(result); var dbModels = await context.Jobs.AnyAsync(); Assert.False(dbModels); }
private static async Task CreateDrivingLicenseCategories(JobFinderDbContext db) { string[] categories = new string[] { "A", "B", "C", "D", "BE", "CE", "DE", "T tb", "T tm", "T ct", "M" }; foreach (string category in categories) { var categoryType = new DrivingCategoryType { Category = category }; await db.AddAsync(categoryType); } await db.SaveChangesAsync(); }
public async Task RemoveCandidate_WithInvalidData_ReturnsFalse() { var context = new JobFinderDbContext(new DbContextOptionsBuilder <JobFinderDbContext>() .UseInMemoryDatabase(Guid.NewGuid().ToString()) .Options); var jobModel = new Job() { Title = "Test Job Title", Location = "Test Location", Description = "Random description", EndDate = new DateTime(2019, 1, 1), Company = new Company() { CompanyName = "Test Company", User = new User() { UserName = "******" } }, Category = new Category() { CategoryType = "NewCategory" }, JobType = new JobType() { Type = "NewType" } }; await context.AddAsync(jobModel); context.SaveChanges(); var jobService = new JobService(new EfRepository <Company>(context), new EfRepository <Job>(context), new EfRepository <JobCandidate>(context), new EfRepository <User>(context), new EfRepository <JobSeeker>(context)); var result = await jobService.RemoveCandidate(jobModel.Id, 2); var dbModels = await context.JobsCandidates.AnyAsync(); Assert.False(dbModels); }
public async Task GetAsync_WithValidJob_WorksCorrectly() { var context = new JobFinderDbContext(new DbContextOptionsBuilder <JobFinderDbContext>() .UseInMemoryDatabase(Guid.NewGuid().ToString()) .Options); var serviceModel = new Job() { Location = "Test Location", Description = "Random description", EndDate = DateTime.UtcNow, Company = new Company() { CompanyName = "Test Company", User = new User() { UserName = "******" }, }, Category = new Category() { CategoryType = "NewCategory" }, JobType = new JobType() { Type = "NewType" } }; await context.AddAsync(serviceModel); context.SaveChanges(); var jobService = new JobService(new EfRepository <Company>(context), new EfRepository <Job>(context), new EfRepository <JobCandidate>(context), new EfRepository <User>(context), new EfRepository <JobSeeker>(context)); var result = await jobService.GetAsync(serviceModel.Id); var dbModel = await context.Jobs.SingleOrDefaultAsync(); Assert.Equal(dbModel.Id, result.Id); }
public async Task GetAllForResume_WithData_WorksCorrectly() { var context = new JobFinderDbContext(new DbContextOptionsBuilder <JobFinderDbContext>() .UseInMemoryDatabase(Guid.NewGuid().ToString()) .Options); var expectedResults = new[] { "Skill1", "Skill2", "Skill3" } .OrderBy(c => c) .ToArray(); var model = new Resume() { Skills = new List <Skill>() { new Skill() { Name = expectedResults[0] }, new Skill() { Name = expectedResults[1] }, new Skill() { Name = expectedResults[2] }, } }; await context.AddAsync(model); context.SaveChanges(); var skillService = new SkillService(new EfRepository <Resume>(context), new EfRepository <Skill>(context)); var actualResults = (await skillService.GetAllForResume(model.Id)) .Select(s => s.Name) .OrderBy(s => s) .ToArray(); Assert.Equal(expectedResults, actualResults); }
public async Task UpdateAsync_WithValidData_ReturnsTrue() { string expectedResult = "NewMajor"; var context = new JobFinderDbContext(new DbContextOptionsBuilder <JobFinderDbContext>() .UseInMemoryDatabase(Guid.NewGuid().ToString()) .Options); var model = new Education() { Major = "MajorTest", Institute = "InstituteTest", From = 2000, To = 2001, }; await context.AddAsync(model); context.SaveChanges(); var serviceModel = new EducationServiceModel() { Id = model.Id, Major = expectedResult, Institute = "InstituteTest", From = 2000, To = 2001, }; var educationsService = new EducationsService(new EfRepository <Education>(context), new EfRepository <Resume>(context)); var result = await educationsService.UpdateAsync(serviceModel); Assert.True(result); var actualResult = (await context.EducationsHistory.SingleAsync(e => e.Id == model.Id)).Major; Assert.Equal(expectedResult, actualResult); }
public async Task UpdateAsync_WithValidData_ReturnsTrue() { string expectedResult = "NewPosition"; var context = new JobFinderDbContext(new DbContextOptionsBuilder <JobFinderDbContext>() .UseInMemoryDatabase(Guid.NewGuid().ToString()) .Options); var model = new WorkExperience() { Position = "PositionTest", Institute = "InstituteTest", From = 2000, To = 2001, }; await context.AddAsync(model); context.SaveChanges(); var serviceModel = new WorkExperienceServiceModel() { Id = model.Id, Position = expectedResult, Institute = "InstituteTest", From = 2000, To = 2001, }; var workService = new WorkHistoryService(new EfRepository <Resume>(context), new EfRepository <WorkExperience>(context)); var result = await workService.UpdateAsync(serviceModel); Assert.True(result); var actualResult = (await context.WorksHistory.SingleAsync(w => w.Id == model.Id)).Position; Assert.Equal(expectedResult, actualResult); }
public async Task CreateAsync_WithValidModel_WorksCorrectly_WithSignedUser() { var context = new JobFinderDbContext(new DbContextOptionsBuilder <JobFinderDbContext>() .UseInMemoryDatabase(Guid.NewGuid().ToString()) .Options); var user = new User() { UserName = "******", Email = "*****@*****.**" }; await context.AddAsync(user); context.SaveChanges(); var serviceModel = new ContactMessageServiceModel { Subject = "TestSubjectName", Message = "TestMessage", User = new UserServiceModel() { Id = user.Id } }; var contactMessagesService = new ContactMessagesService(new EfRepository <ContactMessage>(context), new EfRepository <User>(context)); var result = await contactMessagesService.CreateAsync(serviceModel); Assert.True(result); var dbModel = context.ContactMessages.SingleOrDefault(); Assert.NotNull(dbModel); Assert.Equal(user.Id, dbModel.UserId); }
public async Task AddEducation_WithValidData_ToExistingResume_WorksCorrectly() { var context = new JobFinderDbContext(new DbContextOptionsBuilder <JobFinderDbContext>() .UseInMemoryDatabase(Guid.NewGuid().ToString()) .Options); var model = new Resume() { JobSeeker = new JobSeeker() { FirstName = "JobSeekerName1", LastName = "JobSeekerName2", User = new User() { UserName = "******" } } }; await context.AddAsync(model); context.SaveChanges(); var serviceModel = new EducationServiceModel() { Major = "MajorTest", Institute = "InstituteTest", From = 2000, To = 2001, }; var educationsService = new EducationsService(new EfRepository <Education>(context), new EfRepository <Resume>(context)); var result = await educationsService.AddEducation(model.Id, serviceModel); Assert.True(result); }
private static async Task CreateJobEngagements(JobFinderDbContext db) { string[] enumeEngagements = Enum.GetNames(typeof(JobEngagementType)); var engagements = new List <string>(); enumeEngagements.ToList().ForEach(x => engagements.Add(x.SeparateWords())); string[] dbEngagements = db.JobEngagements.Select(x => x.Type).ToArray(); string[] engagementsToWrite = engagements.Where(e => !dbEngagements.Contains(e)).ToArray(); foreach (var engagementType in engagementsToWrite) { var engagement = new JobEngagement { Type = engagementType }; await db.AddAsync(engagement); } await db.SaveChangesAsync(); }
private static async Task CreateJobCategories(JobFinderDbContext db) { var enumCategories = Enum.GetNames(typeof(JobCategoryType)); var categories = new List <string>(); enumCategories.ToList().ForEach(x => categories.Add(x.ReplaceDashesAndSeparate())); string[] dbCategories = db.JobCategories.Select(x => x.Type).ToArray(); string[] categoriesToWrite = categories.Where(e => !dbCategories.Contains(e)).ToArray(); foreach (var categoryType in categoriesToWrite) { var category = new JobCategory { Type = categoryType }; await db.AddAsync(category); } await db.SaveChangesAsync(); }
public async Task GetByIdAsync_WithExistingSkill_WorksCorrectly() { string expectedSkillName = "TestSkill"; var context = new JobFinderDbContext(new DbContextOptionsBuilder <JobFinderDbContext>() .UseInMemoryDatabase(Guid.NewGuid().ToString()) .Options); var model = new Skill() { Name = expectedSkillName }; await context.AddAsync(model); context.SaveChanges(); var skillService = new SkillService(new EfRepository <Resume>(context), new EfRepository <Skill>(context)); var result = await skillService.GetByIdAsync(model.Id); Assert.Equal(expectedSkillName, result.Name); }
public async Task DeleteJobSeeker_WithExistingJobSeeker_WorksCorrectly() { var context = new JobFinderDbContext(new DbContextOptionsBuilder <JobFinderDbContext>() .UseInMemoryDatabase(Guid.NewGuid().ToString()) .Options); var testUsers = new List <User> { new User { UserName = "******", Email = "*****@*****.**", ContactMessages = new List <ContactMessage>() { new ContactMessage() { Subject = "SubjectTest", Message = "MessageTest" } } }, new User { UserName = "******", Email = "*****@*****.**", } }; var model = new JobSeeker() { FirstName = "FirstNameTest1", LastName = "LastNameTest1", User = testUsers[0], UserJobs = new List <JobCandidate>() { new JobCandidate() { Job = new Job() { Title = "Test Job Title1", Location = "Test Location1", Description = "Random description1", EndDate = DateTime.UtcNow.AddDays(1), Category = new Category() { CategoryType = "NewCategory1" }, JobType = new JobType() { Type = "NewType1" } } } }, Resume = new Resume() }; await context.AddAsync(model); context.SaveChanges(); var personalDataService = new PersonalDataService(new EfRepository <Company>(context), new EfRepository <ContactMessage>(context), new EfRepository <Job>(context), new EfRepository <JobSeeker>(context), new EfRepository <JobCandidate>(context), new EfRepository <User>(context), new EfRepository <Resume>(context)); var result = await personalDataService.DeleteJobSeeker(testUsers[0].Id); Assert.True(result); var contactMessagesCount = await context.ContactMessages.CountAsync(); Assert.Equal(0, contactMessagesCount); var jobsCandidateCount = await context.JobsCandidates.CountAsync(); Assert.Equal(0, jobsCandidateCount); var jobSeekersCount = await context.JobSeekers.CountAsync(); Assert.Equal(0, jobSeekersCount); var resumeCount = await context.Resumes.CountAsync(); Assert.Equal(0, resumeCount); var usersCount = await context.Users.CountAsync(); Assert.Equal(0, usersCount); }