public void QueueCsvGenerationMessages_GivenNoSpecificationSummariesFound_ThrowsRetriableException()
{
//Arrange
string errorMessage = "No specification summaries found to generate calculation results csv.";
IEnumerable <SpecificationSummary> specificationSummaries = Enumerable.Empty <SpecificationSummary>();
ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository();
specificationsRepository
.GetSpecificationSummaries()
.Returns(specificationSummaries);
ILogger logger = CreateLogger();
ResultsService resultsService = CreateResultsService(logger, specificationsRepository: specificationsRepository);
//Act
Func <Task> test = async() => await resultsService.QueueCsvGenerationMessages();
//Assert
test
.Should()
.ThrowExactly <RetriableException>()
.Which
.Message
.Should()
.Be(errorMessage);
logger
.Received(1)
.Error(errorMessage);
}
public async Task QueueCsvGenerationMessages_GivenSpecificationSummariesFoundAndHasNewResults_CreatesNewMessage()
{
//Arrange
IEnumerable <SpecificationSummary> specificationSummaries = new[]
{
new SpecificationSummary {
Id = "spec-1"
}
};
ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository();
specificationsRepository
.GetSpecificationSummaries()
.Returns(specificationSummaries);
ICalculationResultsRepository calculationResultsRepository = CreateResultsRepository();
calculationResultsRepository
.CheckHasNewResultsForSpecificationIdAndTimePeriod(
Arg.Is("spec-1"),
Arg.Any <DateTimeOffset>(),
Arg.Any <DateTimeOffset>())
.Returns(true);
ILogger logger = CreateLogger();
IMessengerService messengerService = CreateMessengerService();
ResultsService resultsService = CreateResultsService(
logger,
specificationsRepository: specificationsRepository,
resultsRepository: calculationResultsRepository,
messengerService: messengerService);
//Act
await resultsService.QueueCsvGenerationMessages();
//Assert
await
messengerService
.Received(1)
.SendToQueue(
Arg.Is(ServiceBusConstants.QueueNames.CalculationResultsCsvGeneration),
Arg.Is(string.Empty),
Arg.Is <Dictionary <string, string> >(m => m["specification-id"] == "spec-1"), Arg.Is(false));
logger
.Received()
.Information($"Found new calculation results for specification id 'spec-1'");
}
public async Task ReIndexCalculationResults(Message message)
{
Guard.ArgumentNotNull(message, nameof(message));
Reference user = message.GetUserDetails();
_logger.Information($"{nameof(ReIndexCalculationResults)} initiated by: '{user.Name}'");
IEnumerable <SpecificationSummary> specifications = await _specificationsRepositoryPolicy.ExecuteAsync(() => _specificationsRepository.GetSpecificationSummaries());
foreach (SpecificationSummary specification in specifications)
{
await _resultsRepositoryPolicy.ExecuteAsync(() => _resultsRepository.ProviderResultsBatchProcessing(specification.Id, async(x) => {
IList <ProviderCalculationResultsIndex> results = new List <ProviderCalculationResultsIndex>();
foreach (ProviderResult providerResult in x)
{
if (!providerResult.CalculationResults.IsNullOrEmpty())
{
ProviderCalculationResultsIndex calculationResult = new ProviderCalculationResultsIndex
{
SpecificationId = providerResult.SpecificationId,
SpecificationName = specification?.Name,
ProviderId = providerResult.Provider?.Id,
ProviderName = providerResult.Provider?.Name,
ProviderType = providerResult.Provider?.ProviderType,
ProviderSubType = providerResult.Provider?.ProviderSubType,
LocalAuthority = providerResult.Provider?.Authority,
LastUpdatedDate = providerResult.CreatedAt,
UKPRN = providerResult.Provider?.UKPRN,
URN = providerResult.Provider?.URN,
UPIN = providerResult.Provider?.UPIN,
EstablishmentNumber = providerResult.Provider?.EstablishmentNumber,
OpenDate = providerResult.Provider?.DateOpened,
CalculationId = providerResult.CalculationResults.Select(m => m.Calculation.Id).ToArraySafe(),
CalculationName = providerResult.CalculationResults.Select(m => m.Calculation.Name).ToArraySafe(),
CalculationResult = providerResult.CalculationResults.Select(m => m.Value.HasValue ? m.Value.ToString() : "null").ToArraySafe()
};
if (_featureToggle.IsExceptionMessagesEnabled())
{
calculationResult.CalculationException = providerResult.CalculationResults
.Where(m => !string.IsNullOrWhiteSpace(m.ExceptionType))
.Select(e => e.Calculation.Id)
.ToArraySafe();
calculationResult.CalculationExceptionType = providerResult.CalculationResults
.Select(m => m.ExceptionType ?? string.Empty)
.ToArraySafe();
calculationResult.CalculationExceptionMessage = providerResult.CalculationResults
.Select(m => m.ExceptionMessage ?? string.Empty)
.ToArraySafe();
}
results.Add(calculationResult);
}
}
IEnumerable <IndexError> errors = await _resultsSearchRepositoryPolicy.ExecuteAsync(() => _providerCalculationResultsSearchRepository.Index(results));
if (errors.Any())
{
string errorMessage = $"Failed to index calculation provider result documents with errors: { string.Join(";", errors.Select(m => m.ErrorMessage)) }";
_logger.Error(errorMessage);
throw new RetriableException(errorMessage);
}
}));
}
}
public async Task QueueCsvGenerationMessages()
{
IEnumerable <SpecificationSummary> specificationSummaries = await _specificationsRepositoryPolicy.ExecuteAsync(() => _specificationsRepository.GetSpecificationSummaries());
if (specificationSummaries.IsNullOrEmpty())
{
string errorMessage = "No specification summaries found to generate calculation results csv.";
_logger.Error(errorMessage);
throw new RetriableException(errorMessage);
}
foreach (SpecificationSummary specificationSummary in specificationSummaries)
{
await QueueCsvGenerationMessage(specificationSummary.Id);
}
}
