public async Task GetDistinctFundingTemplateMetadataFundingLinesContents_GivenContentsInCache_ReturnsOkObjecWithResultsFromCache()
{
//Arrange
const string fundingStreamId = "PES";
const string fundingPeriodId = "AY-2020";
const string templateVersion = "1.0";
string cacheKey = $"{CacheKeys.FundingTemplateContentMetadataDistinct}{fundingStreamId}:{fundingPeriodId}:{templateVersion}".ToLowerInvariant();
string blobNamePrefix = $"{fundingStreamId}/{ fundingPeriodId}/{templateVersion}";
IFundingTemplateRepository fundingTemplateRepository = CreateFundingTemplateRepository();
fundingTemplateRepository
.TemplateVersionExists(Arg.Is <string>(_ => _.Contains(blobNamePrefix)))
.Returns(true);
fundingTemplateRepository.GetFundingTemplateVersion(Arg.Is <string>(_ => _.Contains(blobNamePrefix)))
.Returns(string.Empty);
ILogger logger = CreateLogger();
ICacheProvider cacheProvider = CreateCacheProvider();
cacheProvider.GetAsync <TemplateMetadataDistinctContents>(cacheKey)
.Returns(new TemplateMetadataDistinctContents()
{
FundingStreamId = fundingStreamId,
FundingPeriodId = fundingPeriodId,
TemplateVersion = templateVersion
});
FundingTemplateService fundingTemplateService = CreateFundingTemplateService(
logger,
fundingTemplateRepository: fundingTemplateRepository,
cacheProvider: cacheProvider);
//Act
ActionResult <TemplateMetadataDistinctContents> result = await fundingTemplateService.GetDistinctFundingTemplateMetadataContents(fundingStreamId, fundingPeriodId, templateVersion);
//Assert
TemplateMetadataDistinctContents contents = result.Value;
contents.Should().NotBeNull();
contents.FundingStreamId.Should().Be(fundingStreamId);
contents.FundingPeriodId.Should().Be(fundingPeriodId);
contents.TemplateVersion.Should().Be(templateVersion);
await cacheProvider
.Received(1).GetAsync <TemplateMetadataDistinctContents>(cacheKey);
await fundingTemplateRepository
.Received(0).GetFundingTemplateVersion(Arg.Is <string>(_ => _.Contains(blobNamePrefix)));
await cacheProvider
.Received(0)
.SetAsync(cacheKey,
Arg.Is <TemplateMetadataDistinctContents>(_ => _.FundingStreamId == fundingStreamId && _.FundingPeriodId == fundingPeriodId && _.TemplateVersion == templateVersion),
TimeSpan.FromDays(365),
true,
null);
}
private void GivenTemplateMetadataDistinctContents(
HttpStatusCode httpStatusCode,
TemplateMetadataDistinctContents templateMetadataDistinctContents = null)
{
_policiesApiClient
.Setup(_ => _.GetDistinctTemplateMetadataContents(_fundingStreamId,
_fundingPeriodId,
_templateVersion))
.ReturnsAsync(new ApiResponse <TemplateMetadataDistinctContents>(httpStatusCode, templateMetadataDistinctContents));
}
public async Task GetDistinctFundingTemplateMetadataFundingLinesContents_GivenTemplateIsInBlob_ReturnsOkObjecResultstWithDistinctFundingLinesAndCalculations()
{
//Arrange
const string fundingStreamId = "PES";
const string fundingPeriodId = "AY-2020";
const string templateVersion = "1.0";
string template = CreateJsonFile("CalculateFunding.Services.Policy.Resources.LogicalModelTemplateForDistinctMetadataContents.json");
string blobNamePrefix = $"{fundingStreamId}/{ fundingPeriodId}/{templateVersion}";
IFundingTemplateRepository fundingTemplateRepository = CreateFundingTemplateRepository();
fundingTemplateRepository
.TemplateVersionExists(Arg.Is <string>(_ => _.Contains(blobNamePrefix)))
.Returns(true);
fundingTemplateRepository.GetFundingTemplateVersion(Arg.Is <string>(_ => _.Contains(blobNamePrefix)))
.Returns(template);
ILogger logger = CreateLogger();
ICacheProvider cacheProvider = CreateCacheProvider();
FundingTemplateService fundingTemplateService = CreateFundingTemplateService(
logger,
fundingTemplateRepository: fundingTemplateRepository,
cacheProvider: cacheProvider);
//Act
ActionResult <TemplateMetadataDistinctContents> result = await fundingTemplateService.GetDistinctFundingTemplateMetadataContents(fundingStreamId, fundingPeriodId, templateVersion);
//Assert
TemplateMetadataDistinctContents contents = result.Value;
contents.Should().NotBeNull();
contents.FundingLines.Count().Should().Be(2);
contents.Calculations.Count().Should().Be(2);
contents.FundingStreamId.Should().Be(fundingStreamId);
contents.FundingPeriodId.Should().Be(fundingPeriodId);
contents.TemplateVersion.Should().Be(templateVersion);
string cacheKey = $"{CacheKeys.FundingTemplateContentMetadataDistinct}{fundingStreamId}:{fundingPeriodId}:{templateVersion}".ToLowerInvariant();
await cacheProvider
.Received(1)
.SetAsync(cacheKey,
Arg.Is <TemplateMetadataDistinctContents>(_ => _.FundingStreamId == fundingStreamId && _.FundingPeriodId == fundingPeriodId && _.TemplateVersion == templateVersion),
TimeSpan.FromDays(365),
true,
null);
}
public async Task <ActionResult <TemplateMetadataDistinctContents> > GetDistinctFundingTemplateMetadataContents(string fundingStreamId, string fundingPeriodId, string templateVersion)
{
string cacheKey = $"{CacheKeys.FundingTemplateContentMetadataDistinct}{fundingStreamId}:{fundingPeriodId}:{templateVersion}".ToLowerInvariant();
TemplateMetadataDistinctContents templateMetadataDistinctContents = await _cacheProvider.GetAsync <TemplateMetadataDistinctContents>(cacheKey);
if (templateMetadataDistinctContents == null)
{
ActionResult <TemplateMetadataContents> fundingTemplateContentMetadataResult = await GetFundingTemplateContentMetadata(fundingStreamId, fundingPeriodId, templateVersion);
if (fundingTemplateContentMetadataResult.Result != null)
{
return(fundingTemplateContentMetadataResult.Result);
}
TemplateMetadataContents templateMetadataContents = fundingTemplateContentMetadataResult.Value;
IEnumerable <TemplateMetadataCalculation> calculations = null;
IEnumerable <TemplateMetadataFundingLine> fundingLines = null;
if (templateMetadataContents.RootFundingLines != null)
{
IEnumerable <FundingLine> flattenedFundingLines = templateMetadataContents.RootFundingLines.Flatten(x => x.FundingLines);
IEnumerable <Calculation> flatternedCalculations = flattenedFundingLines.SelectMany(fl => fl.Calculations.Flatten(cal => cal.Calculations));
IEnumerable <FundingLine> uniqueFundingLines = flattenedFundingLines.DistinctBy(f => f.TemplateLineId);
IEnumerable <Calculation> uniqueCalculations = flatternedCalculations.DistinctBy(c => c.TemplateCalculationId);
fundingLines = _mapper.Map <IEnumerable <TemplateMetadataFundingLine> >(uniqueFundingLines);
calculations = _mapper.Map <IEnumerable <TemplateMetadataCalculation> >(uniqueCalculations);
}
templateMetadataDistinctContents = new TemplateMetadataDistinctContents()
{
FundingStreamId = templateMetadataContents.FundingStreamId,
FundingPeriodId = templateMetadataContents.FundingPeriodId,
TemplateVersion = templateMetadataContents.TemplateVersion,
SchemaVersion = templateMetadataContents.SchemaVersion,
FundingLines = fundingLines,
Calculations = calculations
};
// We need to cache as long as the data has not been changed
await _cacheProvider.SetAsync(cacheKey, templateMetadataDistinctContents, TimeSpan.FromDays(365), true);
}
return(templateMetadataDistinctContents);
}
public async Task <ActionResult <TemplateMetadataDistinctCalculationsContents> > GetDistinctFundingTemplateMetadataCalculationsContents(string fundingStreamId, string fundingPeriodId, string templateVersion)
{
ActionResult <TemplateMetadataDistinctContents> templateMetadataDistinctContentsResult = await GetDistinctFundingTemplateMetadataContents(fundingStreamId, fundingPeriodId, templateVersion);
if (templateMetadataDistinctContentsResult == null || templateMetadataDistinctContentsResult.Value == null)
{
return(templateMetadataDistinctContentsResult.Result);
}
TemplateMetadataDistinctContents templateMetadataDistinctContents = templateMetadataDistinctContentsResult.Value;
return(new TemplateMetadataDistinctCalculationsContents()
{
FundingStreamId = templateMetadataDistinctContents.FundingStreamId,
FundingPeriodId = templateMetadataDistinctContents.FundingPeriodId,
TemplateVersion = templateMetadataDistinctContents.TemplateVersion,
Calculations = templateMetadataDistinctContents.Calculations,
SchemaVersion = templateMetadataDistinctContents.SchemaVersion
});
}
