public When_EmailService_Is_Called_To_Send_Email_With_Incorrect_Template()
{
var emailHistoryRepository = Substitute.For <IRepository <EmailHistory> >();
var config = new MapperConfiguration(c => c.AddMaps(typeof(EmailHistoryMapper).Assembly));
var mapper = new Mapper(config);
var configuration = new MatchingConfiguration
{
SendEmailEnabled = true
};
_notificationsApi = Substitute.For <IAsyncNotificationClient>();
_logger = Substitute.For <ILogger <EmailService> >();
_emailTemplateRepository = Substitute.For <IRepository <EmailTemplate> >();
_emailTemplateRepository
.GetSingleOrDefaultAsync(Arg.Any <Expression <Func <EmailTemplate, bool> > >())
.ReturnsNull();
var functionLogRepository = Substitute.For <IRepository <FunctionLog> >();
var emailService = new EmailService(configuration, _notificationsApi, _emailTemplateRepository, emailHistoryRepository, functionLogRepository, mapper, _logger);
const string toAddress = "*****@*****.**";
var tokens = new Dictionary <string, string>
{
{ "contactname", "name" }
};
const string templateName = "MissingTestTemplate";
emailService.SendEmailAsync(templateName, toAddress, null, null, tokens, "System").GetAwaiter().GetResult();
}
public LocationApiClient(HttpClient httpClient, MatchingConfiguration matchingConfiguration)
{
_httpClient = httpClient;
_httpClient.DefaultRequestHeaders.Accept.Clear();
_httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
_postcodeRetrieverBaseUrl = matchingConfiguration.PostcodeRetrieverBaseUrl.TrimEnd('/');
}
public When_Employer_Aupa_Blank_Email_Function_Queue_Trigger_Fires()
{
var configuration = new MatchingConfiguration
{
SendEmailEnabled = true,
MatchingServiceSupportEmailAddress = SupportEmailAddress
};
_emailService = Substitute.For <IEmailService>();
_functionLogRepository = Substitute.For <IRepository <FunctionLog> >();
var employerAupaBlankEmail = new SendEmployerAupaBlankEmail
{
CrmId = _employerCrmId,
Name = EmployerName,
Owner = EmployerOwner
};
var employerAupaBlankEmailFunctions = new Functions.EmployerAupaBlankEmail(configuration, _emailService, _functionLogRepository);
employerAupaBlankEmailFunctions.SendEmployerAupaBlankEmailAsync(
employerAupaBlankEmail,
new ExecutionContext(),
new NullLogger <Functions.EmployerAupaBlankEmail>()
).GetAwaiter().GetResult();
}
public When_ProviderQuarterlyUpdateEmail_Controller_ConfirmSendProviderEmail_Post_Is_Called_With_SendEmail_False()
{
var providerService = Substitute.For <IProviderService>();
_providerQuarterlyUpdateEmailService = Substitute.For <IProviderQuarterlyUpdateEmailService>();
const string adminEmail = "*****@*****.**";
var configuration = new MatchingConfiguration
{
AuthorisedAdminUserEmail = adminEmail
};
var providerQuarterlyUpdateEmailController =
new ProviderQuarterlyUpdateEmailController(_providerQuarterlyUpdateEmailService, providerService, configuration);
var controllerWithClaims = new ClaimsBuilder <ProviderQuarterlyUpdateEmailController>(providerQuarterlyUpdateEmailController)
.Add(ClaimTypes.Role, RolesExtensions.AdminUser)
.AddEmail(adminEmail)
.Build();
var viewModel = new ConfirmSendProviderEmailViewModel
{
ProviderCount = 100,
SendEmail = false
};
_result = controllerWithClaims.ConfirmSendProviderEmailAsync(viewModel).GetAwaiter().GetResult();
}
public GoogleMapApiClient(HttpClient httpClient, MatchingConfiguration matchingConfiguration)
{
_httpClient = httpClient;
_matchingConfiguration = matchingConfiguration;
_httpClient.DefaultRequestHeaders.Accept.Clear();
_httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
}
public ProviderFeedbackFixture()
{
Configuration = new MatchingConfiguration
{
ProviderFeedbackEmailsEnabled = true,
ProviderFeedbackWorkingDayInMonth = 10,
SendEmailEnabled = true
};
Logger = Substitute.For <ILogger <ProviderFeedbackService> >();
var mockDbSet = new BankHolidayListBuilder()
.Build()
.AsQueryable()
.BuildMockDbSet();
var contextOptions = new DbContextOptions <MatchingDbContext>();
var mockContext = Substitute.For <MatchingDbContext>(contextOptions);
mockContext.Set <BankHoliday>().Returns(mockDbSet);
BankHolidayRepository =
new GenericRepository <BankHoliday>(NullLogger <GenericRepository <BankHoliday> > .Instance, mockContext);
BankHolidayRepository = Substitute.For <IRepository <BankHoliday> >();
BankHolidayRepository
.GetManyAsync(Arg.Any <Expression <Func <BankHoliday, bool> > >())
.Returns(new List <BankHoliday>().AsQueryable());
}
public async Task Then_Add_To_Failed_Queue_If_Status_Is_Not_Delivered(
string status,
MatchingConfiguration configuration,
IEmailService emailService,
IOpportunityRepository opportunityRepository,
IMessageQueueService messageQueueService,
ILogger <Application.Services.EmailDeliveryStatusService> logger,
EmailDeliveryStatusPayLoad payload
)
{
//Arrange
payload.Status = status;
var sut = new Application.Services.EmailDeliveryStatusService(configuration,
emailService, opportunityRepository, messageQueueService, logger);
var serializedPayLoad = JsonConvert.SerializeObject(payload);
//Act
await sut.HandleEmailDeliveryStatusAsync(serializedPayLoad);
//Assert
await emailService.Received(1).UpdateEmailStatus(Arg.Is <EmailDeliveryStatusPayLoad>(data => data.Status == status));
await messageQueueService.Received(1).PushEmailDeliveryStatusMessageAsync(Arg.Any <SendEmailDeliveryStatus>());
}
public async Task Then_Do_Not_Update_Email_History_If_PayLoad_Is_Null_Or_Empty(
string payload,
MatchingConfiguration configuration,
IRepository <Domain.Models.EmailHistory> emailHistoryRepository,
IEmailService emailService,
IOpportunityRepository opportunityRepository,
IMessageQueueService messageQueueService,
ILogger <Application.Services.EmailDeliveryStatusService> logger,
Domain.Models.EmailHistory emailHistory
)
{
//Arrange
emailHistoryRepository
.GetFirstOrDefaultAsync(Arg.Any <Expression <Func <Domain.Models.EmailHistory, bool> > >())
.Returns(emailHistory);
var sut = new Application.Services.EmailDeliveryStatusService(configuration,
emailService, opportunityRepository, messageQueueService, logger);
//Act
var result = await sut.HandleEmailDeliveryStatusAsync(payload);
//Assert
result.Should().Be(-1);
await emailHistoryRepository.DidNotReceive().GetFirstOrDefaultAsync(Arg.Any <Expression <Func <Domain.Models.EmailHistory, bool> > >());
await emailHistoryRepository.DidNotReceive().UpdateWithSpecifiedColumnsOnlyAsync(
Arg.Any <Domain.Models.EmailHistory>(),
Arg.Any <Expression <Func <Domain.Models.EmailHistory, object> >[]>());
await messageQueueService.DidNotReceive().PushEmailDeliveryStatusMessageAsync(Arg.Any <SendEmailDeliveryStatus>());
}
public async Task Then_Update_Email_History_With_Status(
string status,
MatchingConfiguration configuration,
IEmailService emailService,
IOpportunityRepository opportunityRepository,
IMessageQueueService messageQueueService,
ILogger <Application.Services.EmailDeliveryStatusService> logger,
EmailDeliveryStatusPayLoad payload
)
{
//Arrange
var sut = new Application.Services.EmailDeliveryStatusService(configuration,
emailService, opportunityRepository, messageQueueService, logger);
payload.Status = status;
var serializedPayLoad = JsonConvert.SerializeObject(payload);
emailService.UpdateEmailStatus(Arg.Any <EmailDeliveryStatusPayLoad>()).Returns(1);
//Act
var emailCount = await sut.HandleEmailDeliveryStatusAsync(serializedPayLoad);
//Assert
emailCount.Should().Be(1);
await emailService.Received(1).UpdateEmailStatus(Arg.Any <EmailDeliveryStatusPayLoad>());
await emailService.Received(1).UpdateEmailStatus(Arg.Is <EmailDeliveryStatusPayLoad>(data => data.Status == status));
}
public async Task Then_Do_Not_Update_Email_History_If_Notification_Id_Does_Not_Exists_In_Callback_PayLoad(
string status,
MatchingConfiguration configuration,
IEmailService emailService,
IOpportunityRepository opportunityRepository,
IMessageQueueService messageQueueService,
ILogger <Application.Services.EmailDeliveryStatusService> logger,
EmailDeliveryStatusPayLoad payload
)
{
//Arrange
payload.Id = Guid.Empty;
payload.Status = status;
var sut = new Application.Services.EmailDeliveryStatusService(configuration,
emailService, opportunityRepository, messageQueueService, logger);
var serializedPayLoad = JsonConvert.SerializeObject(payload);
emailService.UpdateEmailStatus(Arg.Any <EmailDeliveryStatusPayLoad>()).Returns(-1);
//Act
var result = await sut.HandleEmailDeliveryStatusAsync(serializedPayLoad);
//Assert
result.Should().Be(-1);
await emailService.Received(1).UpdateEmailStatus(Arg.Is <EmailDeliveryStatusPayLoad>(data => data.Status == status));
await messageQueueService.DidNotReceive().PushEmailDeliveryStatusMessageAsync(Arg.Any <SendEmailDeliveryStatus>());
}
public async Task GovNotifyEmailServiceDoesSomething()
{
var configuration = new MatchingConfiguration
{
GovNotifyApiKey = "test_key"
};
//var mockEmailService = new Mock<IEmailService>();
var templateName = "MY_TEMPLATE";
var toAddress = "*****@*****.**";
dynamic tokens = new { contactname = "name" };
var replyToAddress = "*****@*****.**";
//TODO: Add mocks for the rest of the parameters and fix test
//var emailService = new GovNotifyEmailService(configuration);
//emailService.SendEmail(templateName, toAddress, tokens, replyToAddress);
//var mockEmailService = new Mock<IEmailService>();
//var controller = new HomeController(mockEmailService.Object);
//var result = controller.Index() as ViewResult;
//Assert.IsNotNull(result);
//Assert.IsInstanceOf<EmailViewModel>(result.Model);
}
protected override void ConfigureConfiguration(IServiceCollection services)
{
MatchingConfiguration = new MatchingConfiguration
{
PostcodeRetrieverBaseUrl = "https://postcodes.io",
GoogleMapsApiBaseUrl = "https://google.com"
};
}
public ProviderQuarterlyUpdateEmailController(IProviderQuarterlyUpdateEmailService providerQuarterlyUpdateEmailService,
IProviderService providerService,
MatchingConfiguration configuration)
{
_providerService = providerService;
_providerQuarterlyUpdateEmailService = providerQuarterlyUpdateEmailService;
_configuration = configuration;
}
protected virtual void ConfigureConfiguration(IServiceCollection services)
{
MatchingConfiguration = ConfigurationLoader.Load(
Configuration[Constants.EnvironmentNameConfigKey],
Configuration[Constants.ConfigurationStorageConnectionStringConfigKey],
Configuration[Constants.VersionConfigKey],
Configuration[Constants.ServiceNameConfigKey]);
}
public EmailDeliveryStatus(
MatchingConfiguration matchingConfiguration,
IEmailDeliveryStatusService emailDeliveryStatusService,
IRepository <FunctionLog> functionLogRepository)
{
_matchingConfiguration = matchingConfiguration;
_emailDeliveryStatusService = emailDeliveryStatusService;
_functionLogRepository = functionLogRepository;
}
public EmployerAupaBlankEmail(
MatchingConfiguration matchingConfiguration,
IEmailService emailService,
IRepository <FunctionLog> functionLogRepository)
{
_matchingConfiguration = matchingConfiguration;
_emailService = emailService;
_functionLogRepository = functionLogRepository;
}
public ProviderQuarterlyUpdateEmailFixture()
{
Configuration = new MatchingConfiguration
{
SendEmailEnabled = true
};
DateTimeProvider = Substitute.For <IDateTimeProvider>();
Logger = Substitute.For <ILogger <Application.Services.ProviderQuarterlyUpdateEmailService> >();
}
public EmployerFeedbackFixture()
{
Configuration = new MatchingConfiguration
{
EmployerFeedbackEmailsEnabled = true,
EmployerFeedbackWorkingDayInMonth = 10,
SendEmailEnabled = true
};
Logger = Substitute.For <ILogger <EmployerFeedbackService> >();
}
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 EmailDeliveryStatusService(MatchingConfiguration configuration,
IEmailService emailService,
IOpportunityRepository opportunityRepository,
IMessageQueueService messageQueueService,
ILogger <EmailDeliveryStatusService> logger)
{
_configuration = configuration;
_emailService = emailService;
_opportunityRepository = opportunityRepository;
_messageQueueService = messageQueueService;
_logger = logger;
}
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_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 void Then_Do_Not_Update_Email_History_If_Authorization_Failed(
MatchingConfiguration matchingConfiguration,
EmailDeliveryStatusPayLoad payLoad,
EmailHistory emailHistory,
ExecutionContext context,
IRepository <EmailHistory> emailHistoryRepository,
IMessageQueueService messageQueueService,
IEmailService emailService,
IOpportunityRepository opportunityRepository,
IRepository <FunctionLog> functionLogRepository,
ILogger <EmailDeliveryStatusService> logger
)
{
//Arrange
matchingConfiguration.EmailDeliveryStatusToken = Guid.NewGuid();
var serializedPayLoad = JsonConvert.SerializeObject(payLoad);
var notificationService = new EmailDeliveryStatusService(matchingConfiguration, emailService,
opportunityRepository, messageQueueService, logger);
emailService.UpdateEmailStatus(Arg.Any <EmailDeliveryStatusPayLoad>()).Returns(-1);
var query = new Dictionary <string, StringValues>();
query.TryAdd("content-type", "application/json");
emailHistoryRepository.GetFirstOrDefaultAsync(Arg.Any <Expression <Func <EmailHistory, bool> > >())
.Returns(emailHistory);
//Act
var emailDeliveryStatusFunctions = new Functions.EmailDeliveryStatus(matchingConfiguration, notificationService, functionLogRepository);
var result = await emailDeliveryStatusFunctions.EmailDeliveryStatusHandlerAsync(
HttpRequestSetup(query, serializedPayLoad),
context, logger) as BadRequestObjectResult;
//Assert
result.Should().NotBeNull();
result?.StatusCode.Should().Be(400);
result?.Should().BeOfType <BadRequestObjectResult>();
await emailHistoryRepository.DidNotReceive().UpdateWithSpecifiedColumnsOnlyAsync(Arg.Any <EmailHistory>(),
Arg.Any <Expression <Func <EmailHistory, object> >[]>());
await emailHistoryRepository.DidNotReceive().UpdateWithSpecifiedColumnsOnlyAsync(
Arg.Is <EmailHistory>(eh =>
eh.Status == "delivered" && eh.ModifiedBy == "System"),
Arg.Any <Expression <Func <EmailHistory, object> >[]>());
await messageQueueService.DidNotReceive().PushEmailDeliveryStatusMessageAsync(Arg.Any <SendEmailDeliveryStatus>());
}
public EmployerFeedbackService(
MatchingConfiguration configuration,
ILogger <EmployerFeedbackService> logger,
IEmailService emailService,
IRepository <BankHoliday> bankHolidayRepository,
IOpportunityRepository opportunityRepository,
IDateTimeProvider dateTimeProvider)
{
_configuration = configuration;
_logger = logger;
_emailService = emailService;
_bankHolidayRepository = bankHolidayRepository;
_opportunityRepository = opportunityRepository;
_dateTimeProvider = dateTimeProvider;
}
public EmailService(MatchingConfiguration configuration,
IAsyncNotificationClient notificationClient,
IRepository <EmailTemplate> emailTemplateRepository,
IRepository <EmailHistory> emailHistoryRepository,
IRepository <FunctionLog> functionLogRepository,
IMapper mapper,
ILogger <EmailService> logger)
{
_configuration = configuration;
_emailTemplateRepository = emailTemplateRepository;
_emailHistoryRepository = emailHistoryRepository;
_functionLogRepository = functionLogRepository;
_mapper = mapper;
_notificationClient = notificationClient;
_logger = logger;
}
public When_EmailDeliveryStatusService_Is_Called_To_Send_Email_With_Invalid_Email_And_No_Opportunity()
{
var configuration = new MatchingConfiguration
{
MatchingServiceSupportEmailAddress = SupportEmailAddress
};
var logger = Substitute.For <ILogger <Application.Services.EmailDeliveryStatusService> >();
_emailService = Substitute.For <IEmailService>();
_emailService.GetEmailBodyFromNotifyClientAsync(_notificationId).Returns(
new EmailDeliveryStatusDto
{
Body = "Body",
Subject = "Subject",
EmailDeliveryStatusType = EmailDeliveryStatusType.PermanentFailure
});
_emailService.GetEmailHistoryAsync(_notificationId).Returns(
new EmailHistoryDto
{
NotificationId = _notificationId,
OpportunityId = null,
OpportunityItemId = null,
SentTo = "*****@*****.**",
Status = "permanent-failure",
EmailTemplateId = 11,
EmailTemplateName = "EmployerAupaBlank",
CreatedBy = "CreatedBy"
});
var messageQueueService = Substitute.For <IMessageQueueService>();
_opportunityRepository = Substitute.For <IOpportunityRepository>();
_opportunityRepository.GetEmailDeliveryStatusForEmployerAsync(1, "*****@*****.**").Returns(
new EmailBodyDtoBuilder()
.AddEmployerEmail().Build());
var emailDeliveryStatusService = new Application.Services.EmailDeliveryStatusService(configuration,
_emailService,
_opportunityRepository,
messageQueueService,
logger);
emailDeliveryStatusService.SendEmailDeliveryStatusAsync(_notificationId).GetAwaiter().GetResult();
}
public When_EmailDeliveryStatusService_Is_Called_To_Send_Email_With_Inbox_Full()
{
var configuration = new MatchingConfiguration
{
MatchingServiceSupportEmailAddress = "*****@*****.**"
};
var logger = Substitute.For <ILogger <Application.Services.EmailDeliveryStatusService> >();
_emailService = Substitute.For <IEmailService>();
_emailService.GetEmailBodyFromNotifyClientAsync(_notificationId).Returns(
new EmailDeliveryStatusDto
{
Body = "Body",
Subject = "Subject",
EmailDeliveryStatusType = EmailDeliveryStatusType.TemporaryFailure
});
_emailService.GetEmailHistoryAsync(_notificationId).Returns(
new EmailHistoryDto
{
NotificationId = _notificationId,
OpportunityId = OpportunityId,
OpportunityItemId = OpportunityItemId,
SentTo = "*****@*****.**",
Status = "unknown-failure",
EmailTemplateId = 7,
EmailTemplateName = "ProviderReferralV5",
CreatedBy = "CreatedBy"
});
var messageQueueService = Substitute.For <IMessageQueueService>();
_opportunityRepository = Substitute.For <IOpportunityRepository>();
_opportunityRepository.GetEmailDeliveryStatusForProviderAsync(OpportunityId, "*****@*****.**").Returns(
new EmailBodyDtoBuilder().AddProviderEmail().Build());
var emailDeliveryStatusService = new Application.Services.EmailDeliveryStatusService(configuration,
_emailService,
_opportunityRepository,
messageQueueService,
logger);
emailDeliveryStatusService.SendEmailDeliveryStatusAsync(_notificationId).GetAwaiter().GetResult();
}
public async void Then_Update_Email_History_With_Failed_Status_And_Push_To_Email_Delivery_Status_Queue(
string status,
MatchingConfiguration matchingConfiguration,
EmailDeliveryStatusPayLoad payLoad,
EmailHistory emailHistory,
ExecutionContext context,
IRepository <EmailHistory> emailHistoryRepository,
IMessageQueueService messageQueueService,
IEmailService emailService,
IOpportunityRepository opportunityRepository,
IRepository <FunctionLog> functionLogRepository,
ILogger <EmailDeliveryStatusService> logger
)
{
//Arrange
payLoad.Status = status;
var serializedPayLoad = JsonConvert.SerializeObject(payLoad);
var notificationService = new EmailDeliveryStatusService(matchingConfiguration, emailService,
opportunityRepository, messageQueueService, logger);
emailService.UpdateEmailStatus(Arg.Any <EmailDeliveryStatusPayLoad>()).Returns(1);
var query = new Dictionary <string, StringValues>();
query.TryAdd("content-type", "application/json");
emailHistoryRepository.GetFirstOrDefaultAsync(Arg.Any <Expression <Func <EmailHistory, bool> > >())
.Returns(emailHistory);
//Act
var emailDeliveryStatusFunctions = new Functions.EmailDeliveryStatus(matchingConfiguration, notificationService, functionLogRepository);
var result = await emailDeliveryStatusFunctions.EmailDeliveryStatusHandlerAsync(
HttpRequestSetup(query, serializedPayLoad),
context, logger) as OkObjectResult;
//Assert
result.Should().NotBeNull();
result?.StatusCode.Should().Be(200);
result?.Value.Should().Be("1 records updated.");
await messageQueueService.Received(1).PushEmailDeliveryStatusMessageAsync(Arg.Is <SendEmailDeliveryStatus>(email => email.NotificationId == payLoad.Id));
}
public async void Then_Do_Not_Update_Email_History_If_No_Record_Found(
MatchingConfiguration matchingConfiguration,
EmailDeliveryStatusPayLoad payLoad,
ExecutionContext context,
IRepository <EmailHistory> emailHistoryRepository,
IMessageQueueService messageQueueService,
IEmailService emailService,
IOpportunityRepository opportunityRepository,
IRepository <FunctionLog> functionLogRepository,
ILogger <EmailDeliveryStatusService> logger
)
{
//Arrange
var serializedPayLoad = JsonConvert.SerializeObject(payLoad);
var notificationService = new EmailDeliveryStatusService(matchingConfiguration, emailService,
opportunityRepository, messageQueueService, logger);
emailService.UpdateEmailStatus(Arg.Any <EmailDeliveryStatusPayLoad>()).Returns(-1);
var query = new Dictionary <string, StringValues>();
query.TryAdd("content-type", "application/json");
emailHistoryRepository.GetFirstOrDefaultAsync(Arg.Any <Expression <Func <EmailHistory, bool> > >())
.Returns(Task.FromResult <EmailHistory>(null));
//Act
var emailDeliveryStatusFunctions = new Functions.EmailDeliveryStatus(matchingConfiguration, notificationService, functionLogRepository);
var result = await emailDeliveryStatusFunctions.EmailDeliveryStatusHandlerAsync(
HttpRequestSetup(query, serializedPayLoad),
context, logger) as OkObjectResult;
//Arrange
result.Should().NotBeNull();
result?.StatusCode.Should().Be(200);
result?.Value.Should().Be("-1 records updated.");
await emailHistoryRepository.DidNotReceive().UpdateWithSpecifiedColumnsOnlyAsync(Arg.Any <EmailHistory>(),
Arg.Any <Expression <Func <EmailHistory, object> >[]>());
await messageQueueService.DidNotReceive().PushEmailDeliveryStatusMessageAsync(Arg.Any <SendEmailDeliveryStatus>());
}
private void RegisterServices(IServiceCollection services)
{
_configuration = ConfigurationLoader.Load(
Environment.GetEnvironmentVariable("EnvironmentName"),
Environment.GetEnvironmentVariable("ConfigurationStorageConnectionString"),
Environment.GetEnvironmentVariable("Version"),
Environment.GetEnvironmentVariable("ServiceName"));
services.AddLogging(logging =>
{
logging.AddConsole();
logging.AddDebug();
logging.AddApplicationInsights();
logging.AddFilter((category, level) =>
level >= (category == "Microsoft" ? LogLevel.Error : LogLevel.Information));
});
services.AddHttpContextAccessor();
services.AddAutoMapper(AppDomain.CurrentDomain.GetAssemblies());
services.AddDbContext <MatchingDbContext>(options =>
options.UseSqlServer(_configuration.SqlConnectionString,
builder =>
builder
.EnableRetryOnFailure()
.UseNetTopologySuite()));
services.AddSingleton(_configuration);
services.AddTransient <ISearchProvider, SqlSearchProvider>();
services.AddTransient <IMessageQueueService, MessageQueueService>();
RegisterFileReaders(services);
RegisterRepositories(services);
RegisterApplicationServices(services);
RegisterNotificationsApi(services, _configuration.GovNotifyApiKey);
RegisterApiClient(services);
}
