public async Task <SourceEmployer> DeleteSourceEmployerAsync(SourceEmployer sourceEmployer)
{
var sourceEmployerEntry = SourceEmployers.Remove(sourceEmployer);
await SaveChangesAsync();
return(sourceEmployerEntry.Entity);
}
public async Task <SourceEmployer> InsertSourceEmployerAsync(SourceEmployer sourceEmployer)
{
var sourceEmployerEntry = await SourceEmployers.AddAsync(sourceEmployer);
await SaveChangesAsync();
await sourceEmployerEntry.Reference(s => s.Employer).LoadAsync();
return(sourceEmployerEntry.Entity);
}
private async Task <SourceEmployer> AddSourceEmployerAsync(SourceType sourceType,
HeadHunterEmployer headHunterEmployer)
{
var employer = _storageBroker.SelectAllEmployers()
.FirstOrDefault(item =>
item.Name.ToLower().Equals(headHunterEmployer.Name.ToLower())) ??
await AddEmployerAsync(headHunterEmployer);
var sourceEmployer = new SourceEmployer
{
SourceId = headHunterEmployer.Id,
EmployerId = employer.Id,
SourceTypeId = sourceType.Id,
Url = headHunterEmployer.Url
};
sourceEmployer = await _storageBroker.InsertSourceEmployerAsync(sourceEmployer);
return(sourceEmployer);
}
public ApplicationServiceMock()
{
_fileRepositoryMock = new FileRepository(@"TestUploads\");
_attachmentRepositoryMock = new AttachmentRepositoryMock();
// Arrange
var einToTest = "41-9876543";
var testFileContents = "test";
var data = Encoding.ASCII.GetBytes(testFileContents);
using (var memoryStream = new MemoryStream(data))
{
var fileName = "test.txt";
// Arrange
var einToTest1 = "41-9876544";
var fileName1 = "test1.txt";
var einToTest2 = "41-9876545";
var fileName2 = "test2.txt";
var einToTest3 = "41-9876546";
var fileName3 = "test3.txt";
var einToTest4 = "41-9876547";
var fileName4 = "test4.txt";
var service = new AttachmentService(_fileRepositoryMock, _attachmentRepositoryMock);
var sCAAttachment = service.UploadAttachment(einToTest, memoryStream.ToArray(), fileName, "text/plain");
var sCAWageDeterminationAttachment = service.UploadAttachment(einToTest1, memoryStream.ToArray(), fileName1, "text/plain");
var pieceRateWageInfoAttachment = service.UploadAttachment(einToTest2, memoryStream.ToArray(), fileName2, "text/plain");
var mostRecentPrevailingWageSurveyAttachment = service.UploadAttachment(einToTest3, memoryStream.ToArray(), fileName3, "text/plain");
var hourlyWageInfoAttachment = service.UploadAttachment(einToTest4, memoryStream.ToArray(), fileName4, "text/plain");
var address = new Section14c.Domain.Models.Address
{
City = "Test City",
County = "Some County",
State = "VA",
StreetAddress = "123 Main St",
ZipCode = "12345"
};
var employerInfoProvidingFacilitiesDeductionType = new EmployerInfoProvidingFacilitiesDeductionType
{
ProvidingFacilitiesDeductionType = new Response
{
Display = "Test"
}
};
ICollection <EmployerInfoProvidingFacilitiesDeductionType> eProvidingFacilitiesDeductionType =
new List <EmployerInfoProvidingFacilitiesDeductionType> {
employerInfoProvidingFacilitiesDeductionType
};
EmployerInfo employer = new EmployerInfo
{
SCAAttachmentId = "1234567890",
SCAAttachment = sCAAttachment,
PhysicalAddress = address,
TemporaryAuthority = true,
HasTradeName = false,
ProvidingFacilitiesDeductionType = eProvidingFacilitiesDeductionType
};
SourceEmployer sEmployee = new SourceEmployer {
EmployerName = "Some Name"
};
ICollection <SourceEmployer> sourceEmployer = new List <SourceEmployer> {
sEmployee
};
PrevailingWageSurveyInfo prevailingWageSurveyInfo = new PrevailingWageSurveyInfo
{
AttachmentId = "1234567890",
Attachment = mostRecentPrevailingWageSurveyAttachment,
SourceEmployers = sourceEmployer
};
PieceRateWageInfo pieceRateWageInfo = new PieceRateWageInfo
{
AttachmentId = "1234567890",
Attachment = pieceRateWageInfoAttachment,
SCAWageDeterminationAttachmentId = "1234567890",
SCAWageDeterminationAttachment = sCAWageDeterminationAttachment,
MostRecentPrevailingWageSurvey = prevailingWageSurveyInfo
};
HourlyWageInfo hourlyWageInfo = new HourlyWageInfo
{
AttachmentId = "1234567890",
Attachment = hourlyWageInfoAttachment,
MostRecentPrevailingWageSurvey = prevailingWageSurveyInfo,
SCAWageDeterminationAttachment = sCAWageDeterminationAttachment
};
Response res = new Response
{
Display = "Response Test 1",
IsActive = true
};
WIOAWorker worker1 = new WIOAWorker
{
FullName = "Test 1",
WIOAWorkerVerified = res,
};
ICollection <WIOAWorker> wIOAWorkerCol = null;
wIOAWorkerCol = new List <WIOAWorker>()
{
worker1
};
ICollection <Employee> employees = null;
var emp = new Employee()
{
AvgHourlyEarnings = 1,
AvgWeeklyHours = 1,
CommensurateWageRate = "1",
PrevailingWage = 1,
Name = "test",
NumJobs = 1,
PrimaryDisability = new Response()
{
Display = "Sample Data"
},
ProductivityMeasure = 1.2,
TotalHours = 1.0,
WorkType = "Some Type"
};
employees = new List <Employee>()
{
emp
};
ICollection <WorkSite> workSites = null;
var ws = new WorkSite()
{
Employees = employees,
WorkSiteType = new Response()
{
Display = "Work Site Type"
},
Name = "This Is A Tribute",
SCA = false
};
workSites = new List <WorkSite>()
{
ws, ws, ws
};
WIOA wIOA = new WIOA
{
WIOAWorkers = wIOAWorkerCol,
};
applicationSubmission = new ApplicationSubmission
{
Employer = employer,
PieceRateWageInfo = pieceRateWageInfo,
HourlyWageInfo = hourlyWageInfo,
WIOA = wIOA,
PayType = new Response()
{
Display = "Both"
},
WorkSites = workSites,
EIN = "11-1111111",
Id = "CE7F5AA5-6832-43FE-BAE1-80D14CD8F666",
TotalNumWorkSites = 1,
ContactName = "Tester",
ContactPhone = "123=345-1234",
ContactEmail = "*****@*****.**"
};
applicationSubmissionCollection = new List <ApplicationSubmission>();
applicationSubmissionCollection.Add(applicationSubmission);
}
}
public async Task ShouldAddNewVacancyIfNotExistedInDb()
{
//arrange
var snippetsResponse = new List <HeadHunterSnippet> {
GetRandomHeadHunterSnippet()
};
var vacancyResponse = GetRandomHeadHunterVacancy();
SourceEmployer nullSourceEmployer = null;
SourceArea nullSourceArea = null;
Vacancy nullVacancy = null;
var returnedSourceType = _headHunterSourceType;
var returnedEmployer = new Employer {
Name = vacancyResponse.Employer.Name, Id = 1
};
var returnedSourceEmployer = GetSourceEmployer(returnedEmployer, vacancyResponse, returnedSourceType);
var returnedArea = new Area {
Id = 1, Name = vacancyResponse.Area.Name
};
var returnedSourceArea = GetSourceArea(returnedArea, vacancyResponse, returnedSourceType);
var returnedCurrency = GetCurrency(vacancyResponse);
var returnedVacancy = GetRandomVacancy();
var returnedSkill = new Skill {
Id = 1, Name = "C#"
};
var returnedSubscriptions = new[] { GetRandomSourceSubscription() }.AsAsyncQueryable();
var emptyEmployers = new List <Employer>().AsQueryable();
var emptyAreas = new List <Area>().AsQueryable();
var emptyCurrencies = new List <Currency>().AsQueryable();
var emptySkills = new List <Skill>().AsQueryable();
var emptyEmployments = new List <Employment>().AsQueryable();
var emptySchedules = new List <Schedule>().AsQueryable();
var actualSourceTypeName = "";
var expectedSourceTypeName = returnedSourceType.Name;
_headHunterBrokerMock.Setup(broker => broker.GetSnippets(It.IsAny <HeadHunterSubscriptionParameters>()))
.Returns(GetHeadHunterSnippetsAsync(snippetsResponse));
_headHunterBrokerMock.Setup(broker => broker.GetVacancy(It.IsAny <string>())).ReturnsAsync(vacancyResponse);
_storageBrokerMock.Setup(broker => broker.SelectAllSourceSubscriptions()).Returns(returnedSubscriptions);
_storageBrokerMock.Setup(broker => broker.InsertSourceTypeAsync(It.IsAny <SourceType>()))
.Callback <SourceType>(param => actualSourceTypeName = param.Name)
.ReturnsAsync(returnedSourceType);
_storageBrokerMock.Setup(broker => broker.SelectVacancyBySourceIdAsync(It.IsAny <int>(), It.IsAny <string>()))
.ReturnsAsync(nullVacancy);
_storageBrokerMock.Setup(broker =>
broker.SelectSourceEmployerByIdAndTypeIdAsync(It.IsAny <int>(), It.IsAny <string>()))
.ReturnsAsync(nullSourceEmployer);
_storageBrokerMock.Setup(broker => broker.SelectAllEmployers()).Returns(emptyEmployers);
_storageBrokerMock.Setup(broker => broker.InsertEmployerAsync(It.IsAny <Employer>()))
.ReturnsAsync(returnedEmployer);
_storageBrokerMock.Setup(broker => broker.InsertSourceEmployerAsync(It.IsAny <SourceEmployer>()))
.ReturnsAsync(returnedSourceEmployer);
_storageBrokerMock.Setup(broker =>
broker.SelectSourceAreaByIdAndTypeIdAsync(It.IsAny <int>(), It.IsAny <string>()))
.ReturnsAsync(nullSourceArea);
_storageBrokerMock.Setup(broker => broker.SelectAllAreas()).Returns(emptyAreas);
_storageBrokerMock.Setup(broker => broker.InsertAreaAsync(It.IsAny <Area>())).ReturnsAsync(returnedArea);
_storageBrokerMock.Setup(broker => broker.InsertSourceAreaAsync(It.IsAny <SourceArea>()))
.ReturnsAsync(returnedSourceArea);
_storageBrokerMock.Setup(broker => broker.SelectAllCurrencies()).Returns(emptyCurrencies);
_storageBrokerMock.Setup(broker => broker.InsertCurrencyAsync(It.IsAny <Currency>()))
.ReturnsAsync(returnedCurrency);
_storageBrokerMock.Setup(broker => broker.InsertVacancyAsync(It.IsAny <Vacancy>()))
.ReturnsAsync(returnedVacancy);
_storageBrokerMock.Setup(broker => broker.SelectAllSkills()).Returns(emptySkills);
_storageBrokerMock.Setup(broker => broker.InsertSkillAsync(It.IsAny <Skill>())).ReturnsAsync(returnedSkill);
_storageBrokerMock.Setup(broker => broker.SelectAllSchedules()).Returns(emptySchedules);
_storageBrokerMock.Setup(broker => broker.SelectAllEmployments()).Returns(emptyEmployments);
//act
await _sourceService.UpdateAllSubscriptions();
//assert
_headHunterBrokerMock.Verify(broker => broker.GetSnippets(It.IsAny <HeadHunterSubscriptionParameters>()),
Times.Once);
_headHunterBrokerMock.Verify(broker => broker.GetVacancy(It.IsAny <string>()), Times.Once);
_storageBrokerMock.Verify(broker => broker.SelectAllSourceSubscriptions(), Times.Once);
actualSourceTypeName.Should().Equals(expectedSourceTypeName);
_storageBrokerMock.Verify(
broker => broker.SelectVacancyBySourceIdAsync(It.IsAny <int>(), It.IsAny <string>()), Times.Once);
_storageBrokerMock.Verify(
broker => broker.SelectSourceEmployerByIdAndTypeIdAsync(It.IsAny <int>(), It.IsAny <string>()),
Times.Once);
_storageBrokerMock.Verify(broker => broker.SelectAllEmployers(), Times.Once);
_storageBrokerMock.Verify(broker => broker.InsertEmployerAsync(It.IsAny <Employer>()), Times.Once);
_storageBrokerMock.Verify(broker => broker.InsertSourceEmployerAsync(It.IsAny <SourceEmployer>()),
Times.Once);
_storageBrokerMock.Verify(
broker => broker.SelectSourceAreaByIdAndTypeIdAsync(It.IsAny <int>(), It.IsAny <string>()), Times.Once);
_storageBrokerMock.Verify(broker => broker.SelectAllAreas(), Times.Once);
_storageBrokerMock.Verify(broker => broker.InsertAreaAsync(It.IsAny <Area>()), Times.Once);
_storageBrokerMock.Verify(broker => broker.InsertSourceAreaAsync(It.IsAny <SourceArea>()), Times.Once);
_storageBrokerMock.Verify(broker => broker.SelectAllCurrencies(), Times.Once);
_storageBrokerMock.Verify(broker => broker.InsertCurrencyAsync(It.IsAny <Currency>()), Times.Once);
_storageBrokerMock.Verify(broker => broker.InsertVacancyAsync(It.IsAny <Vacancy>()), Times.Once);
_storageBrokerMock.Verify(broker => broker.SelectAllSkills(), Times.Once);
_storageBrokerMock.Verify(broker => broker.InsertSkillAsync(It.IsAny <Skill>()), Times.Once);
_storageBrokerMock.Verify(broker => broker.SelectAllSchedules(), Times.Once);
_storageBrokerMock.Verify(broker => broker.InsertScheduleAsync(It.IsAny <Schedule>()), Times.Once);
_storageBrokerMock.Verify(broker => broker.SelectAllEmployments(), Times.Once);
_storageBrokerMock.Verify(broker => broker.InsertEmploymentAsync(It.IsAny <Employment>()), Times.Once);
_storageBrokerMock.Verify(broker => broker.InsertVacancySkillsAsync(It.IsAny <VacancySkill>()), Times.Once);
_storageBrokerMock.Verify(broker => broker.InsertSubscriptionVacancyAsync(It.IsAny <SubscriptionVacancy>()),
Times.Once);
_storageBrokerMock.VerifyNoOtherCalls();
_headHunterBrokerMock.VerifyNoOtherCalls();
}
