public async Task Then_Do_Not_Delete_Opportunity(
[Frozen] IOpportunityRepository opportunityRepo,
[Frozen] IRepository <OpportunityItem> opportunityItemRepo,
[Frozen] IRepository <Domain.Models.Referral> referralRepo,
[Frozen] IRepository <ProvisionGap> provisionGapRepo,
OpportunityItem opportunityItem,
OpportunityService sut)
{
//Arrange
opportunityItem.IsSaved = true;
opportunityItemRepo.GetManyAsync(Arg.Any <Expression <Func <OpportunityItem, bool> > >()).Returns(new List <OpportunityItem>
{
opportunityItem
}.AsQueryable());
referralRepo.GetManyAsync(Arg.Any <Expression <Func <Domain.Models.Referral, bool> > >()).Returns(opportunityItem.Referral.AsQueryable());
provisionGapRepo.GetManyAsync(Arg.Any <Expression <Func <ProvisionGap, bool> > >()).Returns(opportunityItem.ProvisionGap.AsQueryable());
//Act
await sut.DeleteOpportunityItemAsync(opportunityItem.OpportunityId, opportunityItem.OpportunityId);
//Assert
await opportunityRepo.DidNotReceive().DeleteAsync(Arg.Any <int>());
}
public async Task Then_Reasons_Should_Have_Only_Related_To_No_Suitable_Students(
MatchingDbContext dbContext,
OpportunityItem opportunityItem,
IMapper mapper,
[Frozen] ILogger <OpportunityRepository> logger,
[Frozen] IRepository <OpportunityItem> opportunityItemRepository,
[Frozen] IRepository <ProvisionGap> provisionGapRepository,
[Frozen] IRepository <Domain.Models.Referral> referralRepository,
[Frozen] IGoogleMapApiClient googleMapApiClient,
[Frozen] IFileWriter <OpportunityReportDto> opportunityPipelineReportWriter,
[Frozen] IDateTimeProvider dateTimeProvider
)
{
await SetProvisionGapData(dbContext, opportunityItem, false, true, false);
var opportunityRepository = new OpportunityRepository(logger, dbContext);
var sut = new OpportunityService(mapper, opportunityRepository, opportunityItemRepository,
provisionGapRepository, referralRepository, googleMapApiClient,
opportunityPipelineReportWriter, dateTimeProvider);
var result = await sut.GetOpportunityBasketAsync(opportunityItem.OpportunityId);
result.ProvisionGapItems.Should().Contain(model => model.OpportunityType == "ProvisionGap").Which.Reason
.Should().Contain("Providers do not have students doing the right course");
result.ProvisionGapItems.Should().Contain(model => model.OpportunityType == "ProvisionGap").Which.Reason
.Should().NotContain("Employer had a bad experience with them");
}
public When_MatchingServiceOpportunityReport_Is_Called_For_Pipeline_Opportunity()
{
_dbContext = new TestConfiguration().GetDbContext();
_opportunityBuilder = new OpportunityBuilder(_dbContext);
_providerBuilder = new ProviderBuilder(_dbContext);
_employerBuilder = new EmployerBuilder(_dbContext);
_postcodeLookupBuilder = new PostcodeLookupBuilder(_dbContext);
_localEnterprisePartnershipBuilder = new LocalEnterprisePartnershipBuilder(_dbContext);
ClearData();
var employer = _employerBuilder.CreateEmployer(Guid.NewGuid());
var provider = _providerBuilder.CreateProvider();
_localEnterprisePartnershipBuilder.CreateLocalEnterprisePartnership();
_postcodeLookupBuilder.CreatePostcodeLookup();
_savedReferralOpportunityItem = _opportunityBuilder.CreateReferralOpportunityItem(true, false, provider.ProviderVenue.First().Id);
_savedProvisionGapOpportunityItem = _opportunityBuilder.CreateProvisionGapOpportunityItem(true, false);
_opportunityBuilder.CreateOpportunity(employer.CrmId, new List <OpportunityItem> {
_savedReferralOpportunityItem, _savedProvisionGapOpportunityItem
});
_result = _dbContext.MatchingServiceOpportunityReport.ToList();
}
public When_OpportunityService_Is_Called_To_Save_PlacementInformation_With_Empty_Job_Title()
{
var config = new MapperConfiguration(c => c.AddMaps(typeof(OpportunityMapper).Assembly));
var mapper = new Mapper(config);
_opportunityItemRepository = Substitute.For <IRepository <OpportunityItem> >();
var opportunityRepository = Substitute.For <IOpportunityRepository>();
var provisionGapRepository = Substitute.For <IRepository <ProvisionGap> >();
var referralRepository = Substitute.For <IRepository <Domain.Models.Referral> >();
var googleMapApiClient = Substitute.For <IGoogleMapApiClient>();
var opportunityPipelineReportWriter = Substitute.For <IFileWriter <OpportunityReportDto> >();
var dateTimeProvider = Substitute.For <IDateTimeProvider>();
var opportunityItem = new OpportunityItem {
Id = OpportunityItemId, Postcode = Postcode, SearchRadius = Distance, RouteId = RouteId
};
_opportunityItemRepository.GetSingleOrDefaultAsync(Arg.Any <Expression <Func <OpportunityItem, bool> > >()).Returns(opportunityItem);
var opportunityService = new OpportunityService(mapper, opportunityRepository, _opportunityItemRepository,
provisionGapRepository, referralRepository, googleMapApiClient,
opportunityPipelineReportWriter, dateTimeProvider);
var dto = new PlacementInformationSaveDto
{
OpportunityItemId = OpportunityItemId,
JobRole = JobRole,
PlacementsKnown = PlacementsKnown,
Placements = Placements
};
opportunityService.UpdateOpportunityItemAsync(dto).GetAwaiter().GetResult();
}
internal static Opportunity CreateNReferrals(int nItems)
{
const int opportunityId = 3000;
var opportunityItemId = 4000;
var referralId = 5000;
var items = new List <OpportunityItem>();
for (var nItem = 1; nItem <= nItems; nItem++)
{
var item = new OpportunityItem
{
Id = opportunityItemId,
OpportunityId = opportunityId,
OpportunityType = OpportunityType.Referral.ToString(),
Town = "London",
Postcode = "SW1A 2AA",
SearchResultProviderCount = 1,
JobRole = "Job Role",
PlacementsKnown = true,
Placements = 1,
IsSaved = true,
IsSelectedForReferral = false,
IsCompleted = false,
RouteId = 1,
CreatedOn = new DateTime(2019, 1, 2),
CreatedBy = "Dev Surname",
Referral = new List <Referral>
{
new Referral
{
Id = referralId,
ProviderVenueId = 1,
DistanceFromEmployer = 1.23m,
CreatedOn = new DateTime(2019, 1, 2),
CreatedBy = "Dev Surname",
}
}
};
referralId += 1;
opportunityItemId += 1;
items.Add(item);
}
var opportunity = new Opportunity
{
Id = opportunityId,
EmployerCrmId = new Guid("11111111-1111-1111-1111-111111111111"),
EmployerContact = "Employer Contact",
EmployerContactEmail = "*****@*****.**",
EmployerContactPhone = "01474 787878",
CreatedOn = new DateTime(2019, 1, 2),
CreatedBy = "Dev Surname",
OpportunityItem = items
};
return(opportunity);
}
public When_MatchingServiceOpportunityReport_Is_Called_For_Saved_OpportunityOpportunities()
{
_dbContext = new TestConfiguration().GetDbContext();
_opportunityBuilder = new OpportunityBuilder(_dbContext);
_providerBuilder = new ProviderBuilder(_dbContext);
_employerBuilder = new EmployerBuilder(_dbContext);
ClearData();
var employer = _employerBuilder.CreateEmployer(Guid.NewGuid());
var provider1 = _providerBuilder.CreateProvider();
var provider2 = _providerBuilder.CreateProvider();
_savedReferralOpportunityItem = _opportunityBuilder.CreateReferralOpportunityItem(true, true, provider1.ProviderVenue.First().Id);
_savedProvisionGapOpportunityItem = _opportunityBuilder.CreateProvisionGapOpportunityItem(true, true);
_unsavedReferralOpportunityItem = _opportunityBuilder.CreateReferralOpportunityItem(false, false, provider2.ProviderVenue.First().Id);
_unsavedProvisionGapOpportunityItem = _opportunityBuilder.CreateProvisionGapOpportunityItem(false, false);
_opportunityBuilder.CreateOpportunity(employer.CrmId, new List <OpportunityItem> {
_savedReferralOpportunityItem, _savedProvisionGapOpportunityItem, _unsavedReferralOpportunityItem, _unsavedProvisionGapOpportunityItem
});
_result = _dbContext.MatchingServiceOpportunityReport.ToList();
}
public async Task Then_Send_Email_And_Save_Email_History(
MatchingConfiguration configuration,
[Frozen] MatchingDbContext dbContext,
IAsyncNotificationClient notificationClient,
ILogger <GenericRepository <EmailTemplate> > emailTemplateLogger,
ILogger <GenericRepository <EmailHistory> > emailHistoryLogger,
ILogger <GenericRepository <FunctionLog> > functionLogLogger,
ILogger <EmailService> emailServiceLogger,
[Frozen] Domain.Models.Opportunity opportunity,
[Frozen] OpportunityItem opportunityItem,
[Frozen] Domain.Models.Provider provider,
[Frozen] Domain.Models.ProviderVenue venue,
[Frozen] BackgroundProcessHistory backgroundProcessHistory,
[Frozen] EmailHistory emailHistory,
[Frozen] EmailTemplate emailTemplate,
[Frozen] EmailNotificationResponse emailNotificationResponse
)
{
//Arrange
var(templateRepository, emailHistoryRepository, functionLogRepository, mapper)
= SetUp(dbContext, emailTemplateLogger, emailHistoryLogger, functionLogLogger);
var sut = new EmailService(configuration, notificationClient, templateRepository, emailHistoryRepository,
functionLogRepository, mapper, emailServiceLogger);
var tokens = new Dictionary <string, string>
{
{ "contactname", "name" }
};
notificationClient.SendEmailAsync(Arg.Any <string>(), Arg.Any <string>(),
Arg.Any <Dictionary <string, dynamic> >()).Returns(Task.FromResult(emailNotificationResponse));
await DataBuilder.SetTestData(dbContext, provider, venue, opportunity, backgroundProcessHistory);
await DataBuilder.SetEmailTemplate(dbContext, emailTemplate);
//Act
await sut.SendEmailAsync(emailTemplate.TemplateName, "*****@*****.**", opportunity.Id, opportunityItem.Id, tokens, "System");
//Assert
Guid.TryParse(emailNotificationResponse.id, out var notificationId);
var data = dbContext.EmailHistory.AsNoTracking().FirstOrDefault(x => x.NotificationId == notificationId);
data.Should().NotBeNull();
data?.EmailTemplateId.Should().Be(emailHistory.EmailTemplateId);
data?.Status.Should().BeNullOrEmpty();
data?.NotificationId.Should().Be(emailNotificationResponse.id);
data?.CreatedBy.Should().Be("System");
data?.SentTo.Should().Be("*****@*****.**");
}
public OpportunityItemBuilder()
{
_opportunityItem = new OpportunityItem
{
Id = 1,
OpportunityId = 2,
OpportunityType = OpportunityType.Referral.ToString(),
CreatedBy = "CreatedBy",
Opportunity = new Domain.Models.Opportunity
{
Id = 2,
CreatedBy = "CreatedBy"
}
};
}
public When_MatchingServiceProviderOpportunityReport_Is_Called_For_Single_Provider_Multiple_Venues()
{
_dbContext = new TestConfiguration().GetDbContext();
_opportunityBuilder = new OpportunityBuilder(_dbContext);
_providerBuilder = new ProviderBuilder(_dbContext);
_employerBuilder = new EmployerBuilder(_dbContext);
ClearData();
var employer = _employerBuilder.CreateEmployer(Guid.NewGuid());
var provider = _providerBuilder.CreateProvider(2);
_savedReferralOpportunityItem = _opportunityBuilder.CreateReferralOpportunityItem(true, true, provider.ProviderVenue.Select(pv => pv.Id).ToArray());
_opportunityBuilder.CreateOpportunity(employer.CrmId, new List <OpportunityItem> {
_savedReferralOpportunityItem
});
_result = _dbContext.MatchingServiceProviderOpportunityReport.ToList();
}
private static async Task SetProvisionGapData(
MatchingDbContext dbContext,
OpportunityItem opportunityItem,
bool hasBadExperience,
bool hasNoSuitableStudent,
bool areProvidersTooFarAway)
{
opportunityItem.OpportunityType = "ProvisionGap";
opportunityItem.IsSaved = true;
opportunityItem.IsCompleted = false;
//Need to remove extra referral/provision gap rows created as AutoDomainData
foreach (var x in opportunityItem.ProvisionGap.Where(pg => pg.Id != opportunityItem.ProvisionGap.First().Id).ToList())
{
opportunityItem.ProvisionGap.Remove(x);
}
opportunityItem.Referral.Clear();
await dbContext.OpportunityItem.AddAsync(opportunityItem);
await dbContext.SaveChangesAsync();
dbContext.DetachAllEntities();
//Set up the provision gap record
var provisionGap = await dbContext.ProvisionGap.AsNoTracking().FirstOrDefaultAsync();
provisionGap.HadBadExperience = hasBadExperience;
provisionGap.NoSuitableStudent = hasNoSuitableStudent;
provisionGap.ProvidersTooFarAway = areProvidersTooFarAway;
dbContext.Entry(provisionGap).Property("HadBadExperience").IsModified = true;
dbContext.Entry(provisionGap).Property("NoSuitableStudent").IsModified = true;
dbContext.Entry(provisionGap).Property("ProvidersTooFarAway").IsModified = true;
await dbContext.SaveChangesAsync();
dbContext.DetachAllEntities();
}
