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 GetJobSeekerForUser_WithValidUser_WorksCorrectly()
{
string userName = "******";
var context = new JobFinderDbContext(new DbContextOptionsBuilder <JobFinderDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options);
var model = new JobSeeker
{
FirstName = "TestFirstName",
LastName = "TestLastName",
User = new User
{
UserName = userName
}
};
await context.JobSeekers.AddAsync(model);
context.SaveChanges();
var jobSeekerService = new JobSeekerService(new EfRepository <User>(context),
new EfRepository <JobSeeker>(context));
var serviceModel = await jobSeekerService.GetJobSeeker(userName);
var dbModel = await context.JobSeekers.SingleOrDefaultAsync();
Assert.Equal(dbModel.Id, serviceModel.Id);
}
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 UpdateAsync_WithInvalidModel_ReturnsFalse()
{
var context = new JobFinderDbContext(new DbContextOptionsBuilder <JobFinderDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options);
var model = new JobSeeker
{
FirstName = "TestFirstName",
LastName = "TestLastName",
User = new User
{
UserName = "******"
}
};
await context.JobSeekers.AddAsync(model);
context.SaveChanges();
var companyService = new CompanyService(new EfRepository <User>(context),
new EfRepository <Company>(context));
var serviceModel = new JobSeekerServiceModel
{
Id = model.Id
};
var jobSeekerService = new JobSeekerService(new EfRepository <User>(context),
new EfRepository <JobSeeker>(context));
var result = await jobSeekerService.UpdateAsync(serviceModel);
Assert.False(result);
}
public async Task CreateAsync_WithInValidModel_ReturnsFalse()
{
var context = new JobFinderDbContext(new DbContextOptionsBuilder <JobFinderDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options);
var user = new User
{
UserName = "******"
};
await context.Users.AddAsync(user);
context.SaveChanges();
var serviceModel = new CompanyServiceModel
{
User = new UserServiceModel
{
UserName = user.UserName
}
};
var companyService = new CompanyService(new EfRepository <User>(context),
new EfRepository <Company>(context));
var result = await companyService.CreateAsync(serviceModel);
Assert.False(result);
var dbModels = await context.Companies.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 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_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 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 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 GetAllByCategoriesAsyncWithData_WorksCorrectly()
{
var expectedResults = new[] { "Category1", "Category2", "Category3" }
.OrderBy(c => c)
.ToArray();
var context = new JobFinderDbContext(new DbContextOptionsBuilder <JobFinderDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options);
foreach (var model in expectedResults)
{
context.Categories.Add(new Category
{
CategoryType = model
});
}
context.SaveChanges();
var categoriesService = new CategoryService(new EfRepository <Category>(context));
var actualResults = (await categoriesService.GetAllAsync())
.Select(c => c.CategoryType)
.OrderBy(c => c)
.ToArray();
Assert.Equal(expectedResults, actualResults);
}
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 GetCompanyForUser_WithNonExistentUser_ReturnsNull()
{
var testUserName = Guid.NewGuid().ToString();
var context = new JobFinderDbContext(new DbContextOptionsBuilder <JobFinderDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options);
var company = new Company
{
CompanyName = "CompanyName",
User = new User()
{
UserName = "******"
}
};
await context.Companies.AddAsync(company);
context.SaveChanges();
var companyService = new CompanyService(new EfRepository <User>(context),
new EfRepository <Company>(context));
var result = await companyService.GetCompanyForUser(testUserName);
Assert.Null(result);
}
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 GetAsync_WithValidCompany_WorksCorrectly()
{
var context = new JobFinderDbContext(new DbContextOptionsBuilder <JobFinderDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options);
var company = new Company
{
CompanyName = "TestCompanyName123456",
User = new User()
{
UserName = "******"
}
};
await context.Companies.AddAsync(company);
context.SaveChanges();
var companyService = new CompanyService(new EfRepository <User>(context),
new EfRepository <Company>(context));
var result = await companyService.GetAsync(company.Id);
var dbModel = await context.Companies.SingleOrDefaultAsync();
Assert.Equal(dbModel.Id, result.Id);
}
public void Delete(T pObject)
{
using (JobFinderDbContext context = new JobFinderDbContext())
{
context.Set <T>().Remove(pObject);
context.SaveChanges();
}
}
public void Add(T pObject)
{
using (JobFinderDbContext context = new JobFinderDbContext())
{
context.Set <T>().Add(pObject);
context.SaveChanges();
}
}
public void SeedRoles()
{
if (!Context.Roles.Any())
{
Context.Roles.Add(new Role { NmRole = "Software Developer", IsActive = true });
Context.Roles.Add(new Role { NmRole = "Front-End Developer", IsActive = true });
Context.Roles.Add(new Role { NmRole = "Back-End Developer", IsActive = true });
Context.Roles.Add(new Role { NmRole = "C# Developer", IsActive = true });
Context.Roles.Add(new Role { NmRole = "Java Developer", IsActive = true });
Context.Roles.Add(new Role { NmRole = "Java Script Developer", IsActive = true });
Context.Roles.Add(new Role { NmRole = "React Developer", IsActive = true });
Context.Roles.Add(new Role { NmRole = "Phyton Developer", IsActive = true });
Context.Roles.Add(new Role { NmRole = "C++ Developer", IsActive = true });
}
Context.SaveChanges();
}
public void Update(T pObject)
{
using (JobFinderDbContext context = new JobFinderDbContext())
{
context.Entry(pObject).State = EntityState.Modified;
context.SaveChanges();
}
}
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 IHttpActionResult CreateCategory([FromBody] Category cat)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.Categories.Add(cat);
db.SaveChanges();
return(CreatedAtRoute("DefaultApi", new { id = cat.Id }, cat));
// we didn't pass an id in the cat data, but when we add the cat object to the database {db.SaveChanges()}, it get the id value that is autogenerated by the sql server.
//var location = Request.RequestUri + "/" + cat.Id.ToString(); //return Created(location, cat);
}
catch (Exception ex)
{
return(BadRequest(ex.Message)); //return Content(HttpStatusCode.BadRequest, ex);
}
}
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 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 IHttpActionResult OpenNotification(int id)
{
try
{
var CurrentUser = db.AspNetUsers.Find(User.Identity.GetUserId());
var not = db.Notifications.Where(x => x.Id == id && x.ReceiverEmail == CurrentUser.Email).FirstOrDefault();
if (not == null)
{
return(NotFound());
}
not.IsRead = true;
db.SaveChanges();
return(Ok(not));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public async Task GetAllForCompany_WithValidCompany_WorksCorrectly()
{
string testUsername = "******";
var context = new JobFinderDbContext(new DbContextOptionsBuilder <JobFinderDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options);
var expectedResult = "Job1";
var model = new Job()
{
Title = expectedResult,
Location = "Test Location",
Description = "Random description",
EndDate = new DateTime(2019, 1, 1),
Company = new Company()
{
CompanyName = "Test Company",
User = new User()
{
UserName = testUsername
}
},
Category = new Category()
{
CategoryType = "NewCategory"
},
JobType = new JobType()
{
Type = "NewType"
}
};
context.Add(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.GetAllForCompany(testUsername))
.Select(j => j.Title)
.SingleOrDefault();
Assert.Equal(expectedResult, 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 IHttpActionResult SuspendJob(int id)
{
try
{
// Get the job if belong to that publisher
var CurrentUserId = User.Identity.GetUserId();
Job job = db.Jobs.Where(x => x.PublisherId == CurrentUserId && x.Id == id).FirstOrDefault();
if (job == null)
{
return(NotFound());
}
job.IsSuspended = true;
db.Configuration.ValidateOnSaveEnabled = false;
db.SaveChanges();
return(Ok());
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
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);
}
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 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);
}
