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);
}
