public async Task Then_Confirm_Remove_Employer_Model_Is_Loaded(
Domain.Models.Opportunity opportunity,
IEmployerService employerService,
EmployerController sut,
[Frozen] RemoveEmployerDto dto
)
{
//Arrange
employerService.GetConfirmDeleteEmployerOpportunityAsync(Arg.Any <int>(), Arg.Any <string>()).Returns(dto);
//Act
var result = await sut.ConfirmDeleteAsync(opportunity.Id) as ViewResult;
//Assert
var viewModel = result?.Model as RemoveEmployerViewModel;
viewModel.Should().NotBeNull();
viewModel?.OpportunityId.Should().Be(opportunity.Id);
viewModel?.ConfirmDeleteText.Should()
.Be($"Confirm you want to delete {dto.OpportunityCount} opportunities created for {dto.EmployerName}");
viewModel?.ConfirmDeleteText.Should()
.NotBe($"Confirm you want to delete {dto.OpportunityCount} opportunity created for {dto.EmployerName}");
viewModel?.WarningDeleteText.Should().Be("This cannot be undone.");
viewModel?.EmployerCount.Should().Be(dto.EmployerCount);
}
public async Task Then_Send_Email_To_Employers(
MatchingDbContext dbContext,
IDateTimeProvider dateTimeProvider,
MapperConfiguration mapperConfiguration,
[Frozen] Domain.Models.Opportunity opportunity,
[Frozen] Domain.Models.Provider provider,
[Frozen] Domain.Models.ProviderVenue venue,
[Frozen] BackgroundProcessHistory backgroundProcessHistory,
[Frozen] IEmailService emailService,
ILogger <OpportunityRepository> logger,
ILogger <GenericRepository <BackgroundProcessHistory> > historyLogger,
ILogger <GenericRepository <OpportunityItem> > itemLogger,
ILogger <GenericRepository <FunctionLog> > functionLogLogger
)
{
//Arrange
backgroundProcessHistory.Status = BackgroundProcessHistoryStatus.Pending.ToString();
await DataBuilder.SetTestData(dbContext, provider, venue, opportunity, backgroundProcessHistory);
var mapper = new Mapper(mapperConfiguration);
var repo = new OpportunityRepository(logger, dbContext);
var backgroundRepo = new GenericRepository <BackgroundProcessHistory>(historyLogger, dbContext);
var itemRepo = new GenericRepository <OpportunityItem>(itemLogger, dbContext);
var functionLogRepository = new GenericRepository <FunctionLog>(functionLogLogger, dbContext);
var sut = new ReferralEmailService(mapper, dateTimeProvider, emailService, repo, itemRepo, backgroundRepo, functionLogRepository);
//Act
await sut.SendEmployerReferralEmailAsync(opportunity.Id, opportunity.OpportunityItem.Select(oi => oi.Id), backgroundProcessHistory.Id, "System");
//Assert
await emailService.Received(1).SendEmailAsync(Arg.Any <string>(), Arg.Any <string>(), Arg.Any <int?>(), Arg.Any <int?>(), Arg.Any <IDictionary <string, string> >(), Arg.Any <string>());
}
public async Task Then_Confirm_Remove_Employer_Model_Is_Loaded_With_No_Employer(
Domain.Models.Opportunity opportunity,
IEmployerService employerService,
EmployerController sut,
[Frozen] RemoveEmployerDto dto
)
{
//Arrange
dto.OpportunityCount = 1;
dto.EmployerCount = 1;
employerService.GetConfirmDeleteEmployerOpportunityAsync(Arg.Any <int>(), Arg.Any <string>()).Returns(dto);
//Act
var result = await sut.ConfirmDeleteAsync(opportunity.Id) as ViewResult;
//Assert
var viewModel = result.GetViewModel <RemoveEmployerViewModel>();
viewModel.OpportunityId.Should().Be(opportunity.Id);
viewModel.ConfirmDeleteText.Should()
.Be($"Confirm you want to delete {dto.OpportunityCount} opportunity created for {dto.EmployerName}");
viewModel.WarningDeleteText.Should().Be("This cannot be undone and will mean you have no more employers with saved opportunities.");
viewModel.SubmitActionText.Should().Be("Confirm and finish");
viewModel.EmployerCount.Should().Be(dto.EmployerCount);
}
public When_OpportunityService_Is_Called_To_Get_Company_Name_With_Aka_And_Employer_Is_Null()
{
var config = new MapperConfiguration(c => c.AddMaps(typeof(OpportunityMapper).Assembly));
var mapper = new Mapper(config);
_opportunityRepository = Substitute.For <IOpportunityRepository>();
var opportunityItemRepository = Substitute.For <IRepository <OpportunityItem> >();
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 opportunity = new Domain.Models.Opportunity
{
Id = 1,
Employer = null
};
_opportunityRepository.GetSingleOrDefaultAsync(Arg.Any <Expression <Func <Domain.Models.Opportunity, bool> > >(),
Arg.Any <Expression <Func <Domain.Models.Opportunity, object> > >())
.Returns(opportunity);
var opportunityService = new OpportunityService(mapper, _opportunityRepository, opportunityItemRepository, provisionGapRepository,
referralRepository, googleMapApiClient,
opportunityPipelineReportWriter, dateTimeProvider);
_result = opportunityService.GetCompanyNameWithAkaAsync(1).GetAwaiter().GetResult();
}
public async Task Then_Send_Email_Is_Called_With_Employer_Details(
[Frozen] MatchingDbContext dbContext,
IDateTimeProvider dateTimeProvider,
[Frozen] Mapper mapper,
[Frozen] Domain.Models.Opportunity opportunity,
[Frozen] Domain.Models.Provider provider,
[Frozen] Domain.Models.ProviderVenue venue,
[Frozen] BackgroundProcessHistory backgroundProcessHistory,
[Frozen] IEmailService emailService,
ILogger <OpportunityRepository> logger,
ILogger <GenericRepository <BackgroundProcessHistory> > historyLogger,
ILogger <GenericRepository <OpportunityItem> > itemLogger,
ILogger <GenericRepository <FunctionLog> > functionLogLogger
)
{
//Arrange
backgroundProcessHistory.Status = BackgroundProcessHistoryStatus.Pending.ToString();
await DataBuilder.SetTestData(dbContext, provider, venue, opportunity, backgroundProcessHistory);
var repo = new OpportunityRepository(logger, dbContext);
var backgroundRepo = new GenericRepository <BackgroundProcessHistory>(historyLogger, dbContext);
var itemRepo = new GenericRepository <OpportunityItem>(itemLogger, dbContext);
var functionLogRepository = new GenericRepository <FunctionLog>(functionLogLogger, dbContext);
var sut = new ReferralEmailService(mapper, dateTimeProvider, emailService, repo, itemRepo, backgroundRepo, functionLogRepository);
//Act
await sut.SendProviderReferralEmailAsync(opportunity.Id, opportunity.OpportunityItem.Select(oi => oi.Id), backgroundProcessHistory.Id, "System");
//Assert
await emailService.Received(4).SendEmailAsync(Arg.Any <string>(), Arg.Any <string>(),
Arg.Any <int?>(), Arg.Any <int?>(),
Arg.Any <IDictionary <string, string> >(),
Arg.Any <string>());
await emailService.Received(4).SendEmailAsync(Arg.Any <string>(), Arg.Any <string>(),
Arg.Any <int?>(), Arg.Any <int?>(),
Arg.Is <IDictionary <string, string> >(tokens =>
tokens.ContainsKey("employer_business_name") && tokens["employer_business_name"] == opportunity.Employer.CompanyName.ToTitleCase()),
Arg.Any <string>());
await emailService.Received(4).SendEmailAsync(Arg.Any <string>(), Arg.Any <string>(),
Arg.Any <int?>(), Arg.Any <int?>(),
Arg.Is <IDictionary <string, string> >(tokens =>
tokens.ContainsKey("employer_contact_name") && tokens["employer_contact_name"] == opportunity.EmployerContact.ToTitleCase()),
Arg.Any <string>());
await emailService.Received(4).SendEmailAsync(Arg.Any <string>(), Arg.Any <string>(),
Arg.Any <int?>(), Arg.Any <int?>(),
Arg.Is <IDictionary <string, string> >(tokens =>
tokens.ContainsKey("employer_contact_number") && tokens["employer_contact_number"] == opportunity.EmployerContactPhone),
Arg.Any <string>());
await emailService.Received(4).SendEmailAsync(Arg.Any <string>(), Arg.Any <string>(),
Arg.Any <int?>(), Arg.Any <int?>(),
Arg.Is <IDictionary <string, string> >(tokens =>
tokens.ContainsKey("employer_contact_email") && tokens["employer_contact_email"] == opportunity.EmployerContactEmail),
Arg.Any <string>());
}
public async Task Then_Do_Not_Update_Email_History_If_PayLoad_Notification_Id_Is_Null(
string status,
MatchingDbContext dbContext,
[Frozen] Domain.Models.Opportunity opportunity,
[Frozen] Domain.Models.Provider provider,
[Frozen] Domain.Models.ProviderVenue venue,
[Frozen] EmailHistory emailHistory,
[Frozen] BackgroundProcessHistory backgroundProcessHistory,
IMessageQueueService messageQueueService,
EmailDeliveryStatusPayLoad payload,
MatchingConfiguration configuration,
ILogger <OpportunityRepository> opportunityRepoLogger,
ILogger <GenericRepository <EmailTemplate> > emailTemplateLogger,
ILogger <GenericRepository <EmailHistory> > emailHistoryLogger,
ILogger <GenericRepository <FunctionLog> > functionLogLogger,
ILogger <Application.Services.EmailDeliveryStatusService> emailDeliveryServiceStatusLogger,
ILogger <EmailService> emailServiceLogger,
IAsyncNotificationClient notificationClient
)
{
//Arrange
await DataBuilder.SetTestData(dbContext, provider, venue, opportunity, backgroundProcessHistory);
dbContext.Add(emailHistory);
await dbContext.SaveChangesAsync();
payload.Status = status;
payload.Id = Guid.Empty;
var sut = SutSetUp(dbContext, opportunityRepoLogger, emailTemplateLogger, emailHistoryLogger, functionLogLogger,
emailDeliveryServiceStatusLogger, emailServiceLogger, notificationClient, configuration, messageQueueService);
var serializedPayLoad = JsonConvert.SerializeObject(payload);
//Act
await sut.HandleEmailDeliveryStatusAsync(serializedPayLoad);
//Assert
var data = dbContext.EmailHistory.FirstOrDefault(em => em.NotificationId == payload.Id);
data.Should().BeNull();
var existingData = dbContext.EmailHistory.Where(history => history.OpportunityId == opportunity.Id).ToList();
existingData.Select(history => history.ModifiedBy).Should().Equal(new List <string> {
null, null
});
existingData.Select(history => history.ModifiedOn).Should().Equal(new List <string> {
null, null
});
await messageQueueService.DidNotReceive().PushEmailDeliveryStatusMessageAsync(Arg.Any <SendEmailDeliveryStatus>());
}
public When_OpportunityRepository_GetSingleOrDefault_Is_Called_With_Non_Existent_Id()
{
var logger = Substitute.For <ILogger <GenericRepository <Domain.Models.Opportunity> > >();
using var dbContext = InMemoryDbContext.Create();
dbContext.Add(new ValidOpportunityBuilder().Build());
dbContext.SaveChanges();
var repository = new GenericRepository <Domain.Models.Opportunity>(logger, dbContext);
_result = repository.GetSingleOrDefaultAsync(x => x.Id == 2)
.GetAwaiter().GetResult();
}
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 async Task Then_Send_Email_Is_Called_With_Placements_List(
MatchingDbContext dbContext,
IDateTimeProvider dateTimeProvider,
MapperConfiguration mapperConfiguration,
[Frozen] Domain.Models.Opportunity opportunity,
[Frozen] Domain.Models.Provider provider,
[Frozen] Domain.Models.ProviderVenue venue,
[Frozen] BackgroundProcessHistory backgroundProcessHistory,
[Frozen] IEmailService emailService,
ILogger <OpportunityRepository> logger,
ILogger <GenericRepository <BackgroundProcessHistory> > historyLogger,
ILogger <GenericRepository <OpportunityItem> > itemLogger,
ILogger <GenericRepository <FunctionLog> > functionLogLogger
)
{
//Arrange
backgroundProcessHistory.Status = BackgroundProcessHistoryStatus.Pending.ToString();
await DataBuilder.SetTestData(dbContext, provider, venue, opportunity, backgroundProcessHistory);
var mapper = new Mapper(mapperConfiguration);
var repo = new OpportunityRepository(logger, dbContext);
var backgroundRepo = new GenericRepository <BackgroundProcessHistory>(historyLogger, dbContext);
var itemRepo = new GenericRepository <OpportunityItem>(itemLogger, dbContext);
var functionLogRepository = new GenericRepository <FunctionLog>(functionLogLogger, dbContext);
var sut = new ReferralEmailService(mapper, dateTimeProvider, emailService, repo, itemRepo, backgroundRepo, functionLogRepository);
var itemIds = itemRepo.GetManyAsync(oi => oi.Opportunity.Id == opportunity.Id &&
oi.IsSaved &&
oi.IsSelectedForReferral &&
!oi.IsCompleted).Select(oi => oi.Id);
var expectedResult = await GetExpectedResult(repo, opportunity.Id, itemIds);
//Act
await sut.SendEmployerReferralEmailAsync(opportunity.Id, opportunity.OpportunityItem.Select(oi => oi.Id), backgroundProcessHistory.Id, "System");
//Assert
await emailService.Received(1).SendEmailAsync(Arg.Any <string>(), Arg.Any <string>(), Arg.Any <int?>(), Arg.Any <int?>(),
Arg.Any <IDictionary <string, string> >(), Arg.Any <string>());
await emailService.Received(1).SendEmailAsync(Arg.Any <string>(), Arg.Any <string>(), Arg.Any <int?>(), Arg.Any <int?>(),
Arg.Is <IDictionary <string, string> >(tokens => tokens.ContainsKey("placements_list")), Arg.Any <string>());
await emailService.Received(1).SendEmailAsync(Arg.Any <string>(), Arg.Any <string>(), Arg.Any <int?>(), Arg.Any <int?>(),
Arg.Is <IDictionary <string, string> >(tokens => tokens.ContainsKey("placements_list") && tokens["placements_list"] == expectedResult),
Arg.Any <string>());
}
public async Task Then_Update_Email_History_With_Status_And_Push_To_Email_Delivery_Status_Queue(
string status,
MatchingDbContext dbContext,
MatchingConfiguration configuration,
[Frozen] Domain.Models.Opportunity opportunity,
[Frozen] Domain.Models.Provider provider,
[Frozen] Domain.Models.ProviderVenue venue,
[Frozen] EmailHistory emailHistory,
[Frozen] BackgroundProcessHistory backgroundProcessHistory,
ILogger <OpportunityRepository> opportunityRepoLogger,
IMessageQueueService messageQueueService,
EmailDeliveryStatusPayLoad payload,
ILogger <GenericRepository <EmailTemplate> > emailTemplateLogger,
ILogger <GenericRepository <EmailHistory> > emailHistoryLogger,
ILogger <GenericRepository <FunctionLog> > functionLogLogger,
ILogger <Application.Services.EmailDeliveryStatusService> emailDeliveryServiceStatusLogger,
ILogger <EmailService> emailServiceLogger,
IAsyncNotificationClient notificationClient
)
{
//Arrange
await DataBuilder.SetTestData(dbContext, provider, venue, opportunity, backgroundProcessHistory);
dbContext.Add(emailHistory);
await dbContext.SaveChangesAsync();
dbContext.DetachAllEntities();
payload.Status = status;
payload.Id = emailHistory.NotificationId.GetValueOrDefault();
var sut = SutSetUp(dbContext, opportunityRepoLogger, emailTemplateLogger, emailHistoryLogger, functionLogLogger,
emailDeliveryServiceStatusLogger, emailServiceLogger, notificationClient, configuration, messageQueueService);
var serializedPayLoad = JsonConvert.SerializeObject(payload);
//Act
await sut.HandleEmailDeliveryStatusAsync(serializedPayLoad);
//Assert
var data = dbContext.EmailHistory.FirstOrDefault(em => em.NotificationId == payload.Id);
data.Should().NotBeNull();
data?.NotificationId.Should().Be(payload.Id);
data?.Status.Should().Be(payload.Status);
data?.ModifiedBy.Should().Be("System");
await messageQueueService.Received(1).PushEmailDeliveryStatusMessageAsync(Arg.Any <SendEmailDeliveryStatus>());
}
public async Task Then_Result_Is_Not_Null(
Domain.Models.Opportunity opportunity,
IEmployerService employerService,
EmployerController sut,
[Frozen] RemoveEmployerDto dto)
{
//Arrange
employerService.GetConfirmDeleteEmployerOpportunityAsync(Arg.Any <int>(), Arg.Any <string>()).Returns(dto);
//Act
var result = await sut.ConfirmDeleteAsync(opportunity.Id) as ViewResult;
//Assert
result.Should().NotBeNull();
}
public ValidOpportunityBuilder()
{
_opportunity = new Domain.Models.Opportunity
{
Id = 1,
EmployerCrmId = new Guid("55555555-5555-5555-5555-555555555555"),
EmployerContact = "Employer Contact",
EmployerContactPhone = "020 123 4567",
EmployerContactEmail = "*****@*****.**",
CreatedBy = EntityCreationConstants.CreatedByUser,
CreatedOn = EntityCreationConstants.CreatedOn,
ModifiedBy = EntityCreationConstants.ModifiedByUser,
ModifiedOn = EntityCreationConstants.ModifiedOn
};
}
public Domain.Models.Opportunity CreateOpportunity(Guid employerCrmId, List <OpportunityItem> opportunityItems)
{
var opportunity = new Domain.Models.Opportunity
{
EmployerCrmId = employerCrmId,
EmployerContact = "test",
EmployerContactEmail = "*****@*****.**",
EmployerContactPhone = "01234567890",
OpportunityItem = opportunityItems,
CreatedBy = "Sfa.Tl.Matching.Application.IntegrationTests",
};
_context.Add(opportunity);
_context.SaveChanges();
return(opportunity);
}
public async Task Then_Background_Process_History_Status_Is_Completed(
[Frozen] MatchingDbContext dbContext,
IDateTimeProvider dateTimeProvider,
[Frozen] Mapper mapper,
[Frozen] Domain.Models.Opportunity opportunity,
[Frozen] Domain.Models.Provider provider,
[Frozen] Domain.Models.ProviderVenue venue,
[Frozen] BackgroundProcessHistory backgroundProcessHistory,
[Frozen] IEmailService emailService,
ILogger <OpportunityRepository> logger,
ILogger <GenericRepository <BackgroundProcessHistory> > historyLogger,
ILogger <GenericRepository <OpportunityItem> > itemLogger,
ILogger <GenericRepository <FunctionLog> > functionLogLogger
)
{
//Arrange
backgroundProcessHistory.Status = BackgroundProcessHistoryStatus.Pending.ToString();
await DataBuilder.SetTestData(dbContext, provider, venue, opportunity, backgroundProcessHistory);
var repo = new OpportunityRepository(logger, dbContext);
var backgroundRepo = new GenericRepository <BackgroundProcessHistory>(historyLogger, dbContext);
var itemRepo = new GenericRepository <OpportunityItem>(itemLogger, dbContext);
var functionLogRepository = new GenericRepository <FunctionLog>(functionLogLogger, dbContext);
var sut = new ReferralEmailService(mapper, dateTimeProvider, emailService, repo, itemRepo, backgroundRepo, functionLogRepository);
//Act
await sut.SendProviderReferralEmailAsync(opportunity.Id, opportunity.OpportunityItem.Select(oi => oi.Id), backgroundProcessHistory.Id, "System");
//Assert
await emailService.Received(4).SendEmailAsync(Arg.Any <string>(), Arg.Any <string>(), Arg.Any <int?>(), Arg.Any <int?>(),
Arg.Any <IDictionary <string, string> >(), Arg.Any <string>());
var processStatus = dbContext.BackgroundProcessHistory
.FirstOrDefault(history => history.Id == backgroundProcessHistory.Id)
?.Status;
processStatus.Should().NotBe(BackgroundProcessHistoryStatus.Pending.ToString());
processStatus.Should().NotBe(BackgroundProcessHistoryStatus.Processing.ToString());
processStatus.Should().Be(BackgroundProcessHistoryStatus.Complete.ToString());
}
public When_EmployerService_Is_Called_To_Get_Opportunity_Employer_Owner()
{
var employerRepository = Substitute.For <IRepository <Domain.Models.Employer> >();
_opportunityRepository = Substitute.For <IOpportunityRepository>();
var opportunity = new Domain.Models.Opportunity
{
Id = 1,
CreatedBy = "CreatedBy"
};
_opportunityRepository.GetFirstOrDefaultAsync(Arg.Any <Expression <Func <Domain.Models.Opportunity, bool> > >())
.Returns(opportunity);
var employerService = new EmployerService(employerRepository, _opportunityRepository, Substitute.For <IMapper>(), Substitute.For <IValidator <CrmEmployerEventBase> >(),
Substitute.For <IMessageQueueService>());
_result = employerService.GetEmployerOpportunityOwnerAsync(new Guid("11111111-1111-1111-1111-111111111111")).GetAwaiter().GetResult();
}
//[InlineData("Test", "Test")]
public async Task AND_Secondary_Contact_Name_or_Email_Is_Invalid_Then_Send_Email_Is_NOT_Called(
string secondaryContactName,
string secondaryContactEmail,
[Frozen] MatchingDbContext dbContext,
IDateTimeProvider dateTimeProvider,
[Frozen] Mapper mapper,
[Frozen] Domain.Models.Opportunity opportunity,
[Frozen] Domain.Models.Provider provider,
[Frozen] Domain.Models.ProviderVenue venue,
[Frozen] BackgroundProcessHistory backgroundProcessHistory,
[Frozen] IEmailService emailService,
ILogger <OpportunityRepository> logger,
ILogger <GenericRepository <BackgroundProcessHistory> > historyLogger,
ILogger <GenericRepository <OpportunityItem> > itemLogger,
ILogger <GenericRepository <FunctionLog> > functionLogLogger
)
{
//Arrange
backgroundProcessHistory.Status = BackgroundProcessHistoryStatus.Pending.ToString();
provider.SecondaryContact = secondaryContactName;
provider.SecondaryContactEmail = secondaryContactEmail;
await DataBuilder.SetTestData(dbContext, provider, venue, opportunity, backgroundProcessHistory);
var repo = new OpportunityRepository(logger, dbContext);
var backgroundRepo = new GenericRepository <BackgroundProcessHistory>(historyLogger, dbContext);
var itemRepo = new GenericRepository <OpportunityItem>(itemLogger, dbContext);
var functionLogRepository = new GenericRepository <FunctionLog>(functionLogLogger, dbContext);
var sut = new ReferralEmailService(mapper, dateTimeProvider, emailService, repo, itemRepo, backgroundRepo, functionLogRepository);
//Act
await sut.SendProviderReferralEmailAsync(opportunity.Id, opportunity.OpportunityItem.Select(oi => oi.Id), backgroundProcessHistory.Id, "System");
//Assert
await emailService.Received(2).SendEmailAsync(Arg.Any <string>(), Arg.Any <string>(), Arg.Any <int?>(), Arg.Any <int?>(),
Arg.Is <IDictionary <string, string> >(tokens => tokens.ContainsKey("employer_business_name")),
Arg.Any <string>());
}
public async Task Then_Update_Email_History_With_Delivery_Status(
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] Domain.Models.Provider provider,
[Frozen] Domain.Models.ProviderVenue venue,
[Frozen] BackgroundProcessHistory backgroundProcessHistory,
EmailDeliveryStatusPayLoad payLoad,
EmailHistory emailHistory
)
{
//Arrange
var(templateRepositoryLogger, emailHistoryRepository, functionLogRepository, mapper)
= SetUp(dbContext, emailTemplateLogger, emailHistoryLogger, functionLogLogger);
var sut = new EmailService(configuration, notificationClient, templateRepositoryLogger, emailHistoryRepository,
functionLogRepository, mapper, emailServiceLogger);
emailHistory.NotificationId = payLoad.Id;
await DataBuilder.SetTestData(dbContext, provider, venue, opportunity, backgroundProcessHistory);
await DataBuilder.SetEmailHistory(dbContext, emailHistory);
//Act
await sut.UpdateEmailStatus(payLoad);
//Assert
var data = dbContext.EmailHistory.AsNoTracking().FirstOrDefault(x => x.NotificationId == payLoad.Id);
data.Should().NotBeNull();
data?.Status.Should().Be(payLoad.Status);
data?.NotificationId.Should().Be(payLoad.Id);
data?.ModifiedBy.Should().Be("System");
}
public async Task Then_Do_Not_Update_Email_History_If_Does_Not_Exsits(
MatchingDbContext dbContext,
[Frozen] Domain.Models.Opportunity opportunity,
[Frozen] Domain.Models.Provider provider,
[Frozen] Domain.Models.ProviderVenue venue,
[Frozen] BackgroundProcessHistory backgroundProcessHistory,
IMessageQueueService messageQueueService,
EmailDeliveryStatusPayLoad payload,
MatchingConfiguration configuration,
ILogger <OpportunityRepository> opportunityRepoLogger,
ILogger <GenericRepository <EmailTemplate> > emailTemplateLogger,
ILogger <GenericRepository <EmailHistory> > emailHistoryLogger,
ILogger <GenericRepository <FunctionLog> > functionLogLogger,
ILogger <EmailService> emailServiceLogger,
ILogger <Application.Services.EmailDeliveryStatusService> emailDeliveryServiceStatusLogger,
IAsyncNotificationClient notificationClient
)
{
//Arrange
await DataBuilder.SetTestData(dbContext, provider, venue, opportunity, backgroundProcessHistory);
var sut = SutSetUp(dbContext, opportunityRepoLogger, emailTemplateLogger, emailHistoryLogger, functionLogLogger,
emailDeliveryServiceStatusLogger, emailServiceLogger, notificationClient, configuration, messageQueueService);
var serializedPayLoad = JsonConvert.SerializeObject(payload);
//Act
var result = await sut.HandleEmailDeliveryStatusAsync(serializedPayLoad);
//Assert
var data = dbContext.EmailHistory.FirstOrDefault(em => em.NotificationId == payload.Id);
data.Should().BeNull();
result.Should().Be(-1);
await messageQueueService.DidNotReceive().PushEmailDeliveryStatusMessageAsync(Arg.Any <SendEmailDeliveryStatus>());
}
public async Task Then_Send_Referral_Email_To_Employers_Queue(
MatchingDbContext dbContext,
[Frozen] Domain.Models.Opportunity opportunity,
[Frozen] Domain.Models.Provider provider,
[Frozen] Domain.Models.ProviderVenue venue,
[Frozen] BackgroundProcessHistory backgroundProcessHistory,
IMessageQueueService messageQueueService,
IRepository <OpportunityItem> repo,
IRepository <BackgroundProcessHistory> backgroundProcessHistoryRepository
)
{
//Arrange
backgroundProcessHistory.Status = BackgroundProcessHistoryStatus.Pending.ToString();
await DataBuilder.SetTestData(dbContext, provider, venue, opportunity, backgroundProcessHistory);
var sut = new ReferralService(messageQueueService, repo, backgroundProcessHistoryRepository);
repo.GetManyAsync(Arg.Any <Expression <Func <OpportunityItem, bool> > >()).Returns(opportunity.OpportunityItem.AsQueryable());
//Act
await sut.ConfirmOpportunitiesAsync(opportunity.Id, "username");
//Assert
var backgroundProcessData =
dbContext.BackgroundProcessHistory.FirstOrDefault(x => x.Id == backgroundProcessHistory.Id);
await messageQueueService.Received(1)
.PushEmployerReferralEmailMessageAsync(Arg.Any <SendEmployerReferralEmail>());
await messageQueueService.Received(1)
.PushProviderReferralEmailMessageAsync(Arg.Any <SendProviderReferralEmail>());
backgroundProcessData?.Status.Should().Be(BackgroundProcessHistoryStatus.Pending.ToString());
}
public When_OpportunityRepository_Update_Is_Called()
{
var logger = Substitute.For <ILogger <GenericRepository <Domain.Models.Opportunity> > >();
using var dbContext = InMemoryDbContext.Create();
var entity = new ValidOpportunityBuilder().Build();
dbContext.Add(entity);
dbContext.SaveChanges();
var repository = new GenericRepository <Domain.Models.Opportunity>(logger, dbContext);
entity.EmployerContact = "Updated Employer Contact";
entity.EmployerContactPhone = "020 123 9999";
entity.EmployerContactEmail = "*****@*****.**";
entity.ModifiedOn = new DateTime(2019, 11, 01, 12, 30, 00);
entity.ModifiedBy = "UpdateTestUser";
repository.UpdateAsync(entity).GetAwaiter().GetResult();
_result = repository.GetSingleOrDefaultAsync(x => x.Id == 1)
.GetAwaiter().GetResult();
}
