public async Task <PublishedProvider> CreateVersion(PublishedProviderCreateVersionRequest publishedProviderCreateVersionRequest)
{
Guard.ArgumentNotNull(publishedProviderCreateVersionRequest.PublishedProvider, nameof(publishedProviderCreateVersionRequest.PublishedProvider));
Guard.ArgumentNotNull(publishedProviderCreateVersionRequest.NewVersion, nameof(publishedProviderCreateVersionRequest.NewVersion));
PublishedProviderVersion currentVersion = publishedProviderCreateVersionRequest.PublishedProvider.Current;
PublishedProviderVersion newVersion = publishedProviderCreateVersionRequest.NewVersion;
string partitionKey = currentVersion != null ? publishedProviderCreateVersionRequest.PublishedProvider.PartitionKey : string.Empty;
try
{
publishedProviderCreateVersionRequest.PublishedProvider.Current =
await _versionRepositoryPolicy.ExecuteAsync(() => _versionRepository.CreateVersion(newVersion, currentVersion, partitionKey));
}
catch (Exception ex)
{
_logger.Error(ex, $"Failed to create new version for published provider version id: {newVersion.Id}");
throw;
}
return(publishedProviderCreateVersionRequest.PublishedProvider);
}
public async Task AssignDataDefinitionRelationship_GivenUpdatedCosmosAndSearch_LogsSuccess()
{
//Arrange
dynamic anyObject = new { specificationId = SpecificationId, relationshipId = RelationshipId };
string json = JsonConvert.SerializeObject(anyObject);
Message message = new Message(Encoding.UTF8.GetBytes(json));
Specification specification = new Specification
{
Id = SpecificationId,
Name = SpecificationName,
Current = new Models.Specs.SpecificationVersion()
{
FundingStreams = new List <Reference>()
{
new Reference("fs-id", "fs-name")
},
FundingPeriod = new Reference("18/19", "2018/19"),
},
};
ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository();
specificationsRepository
.GetSpecificationById(Arg.Is(SpecificationId))
.Returns(specification);
specificationsRepository
.UpdateSpecification(Arg.Is(specification))
.Returns(HttpStatusCode.OK);
ILogger logger = CreateLogger();
Models.Specs.SpecificationVersion newSpecVersion = specification.Current.Clone() as Models.Specs.SpecificationVersion;
IVersionRepository <Models.Specs.SpecificationVersion> versionRepository = CreateVersionRepository();
versionRepository
.CreateVersion(Arg.Any <Models.Specs.SpecificationVersion>(), Arg.Any <Models.Specs.SpecificationVersion>())
.Returns(newSpecVersion);
SpecificationsService service = CreateService(specificationsRepository: specificationsRepository, logs: logger, specificationVersionRepository: versionRepository);
//Act
await service.Process(message);
//Assert
logger
.Received(1)
.Information($"Successfully assigned relationship id: {RelationshipId} to specification with id: {SpecificationId}");
await _specificationIndexer
.Received(1)
.Index(Arg.Is <Specification>(_ => ReferenceEquals(_.Current, newSpecVersion)));
}
public async Task SetPublishDates_UpdateSpecFails_Returns412WithErrorMessage()
{
//Arrange
ILogger logger = CreateLogger();
string specificationId = "test";
Specification specification = new Specification
{
Current = new SpecificationVersion
{
ExternalPublicationDate = DateTimeOffset.Now.Date,
EarliestPaymentAvailableDate = DateTimeOffset.Now.Date
}
};
SpecificationPublishDateModel specificationPublishDateModel = new SpecificationPublishDateModel()
{
EarliestPaymentAvailableDate = DateTimeOffset.Now.Date,
ExternalPublicationDate = DateTimeOffset.Now.Date
};
IVersionRepository <SpecificationVersion> specificationVersionRepository = CreateSpecificationVersionRepository();
specificationsRepository
.GetSpecificationById(specificationId)
.Returns(specification);
specificationVersionRepository.CreateVersion(Arg.Any <SpecificationVersion>(), Arg.Any <SpecificationVersion>())
.Returns(_ => (SpecificationVersion)_[0]);
specificationsRepository
.UpdateSpecification(Arg.Any <Specification>())
.Returns(HttpStatusCode.BadRequest);
SpecificationsService service = CreateService(
logs: logger,
specificationsRepository: specificationsRepository,
specificationVersionRepository: specificationVersionRepository,
policiesApiClient: policiesApiClient);
// Act
IActionResult result = await service.SetPublishDates(specificationId, specificationPublishDateModel);
//Assert
result
.Should()
.BeOfType <InternalServerErrorResult>()
.Which
.Value
.Should()
.Be($"Failed to update specification for id: test with ExternalPublishDate {specificationPublishDateModel.ExternalPublicationDate} and EarliestPaymentAvailableDate {specificationPublishDateModel.EarliestPaymentAvailableDate}");
}
public async Task SetSpecificationProviderVersion_GivenSpecificationProviderVersionUpdated_ReturnsOkResult()
{
//Arrange
string providerVersionId = NewRandomString();
ValidationResult validationResult = new ValidationResult();
Specification specification = CreateSpecification();
ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository();
specificationsRepository
.GetSpecificationById(Arg.Is(SpecificationId))
.Returns(specification);
SpecificationVersion newSpecVersion = specification.Current.Clone() as SpecificationVersion;
newSpecVersion.ProviderVersionId = providerVersionId;
IVersionRepository <SpecificationVersion> versionRepository = CreateVersionRepository();
versionRepository
.CreateVersion(Arg.Is <SpecificationVersion>(s => s.ProviderVersionId == providerVersionId), Arg.Any <SpecificationVersion>(), null, false)
.Returns(newSpecVersion);
specificationsRepository
.UpdateSpecification(Arg.Is <Specification>(s => s.Current.ProviderVersionId == providerVersionId))
.Returns(HttpStatusCode.OK);
IValidator <AssignSpecificationProviderVersionModel> validator = CreateAssignSpecificationProviderVersionModelValidator(validationResult);
SpecificationsService service = CreateService(assignSpecificationProviderVersionModelValidator: validator, specificationsRepository: specificationsRepository, specificationVersionRepository: versionRepository);
//Act
IActionResult result = await service.SetProviderVersion(new AssignSpecificationProviderVersionModel(SpecificationId, providerVersionId), new Reference());
//Arrange
result
.Should()
.BeOfType <OkResult>();
}
public async Task ResetCalculationForFieldDefinitionChanges_GivenCalculationRequiresReset_UpdatesCalculationsAndDeletesAssembly()
{
//Arrange
const string specificationId = "spec-id";
IEnumerable <DatasetSpecificationRelationshipViewModel> relationships = new[]
{
new DatasetSpecificationRelationshipViewModel
{
Name = "Test Name"
}
};
IEnumerable <string> currentFieldDefinitionNames = new[]
{
"Test Field"
};
ILogger logger = CreateLogger();
CalculationVersion calculationVersion = new CalculationVersion
{
SourceCode = "return Datasets.TestName.TestField",
Date = DateTimeOffset.Now
};
IEnumerable <Calculation> calculations = new[]
{
new Calculation
{
Current = calculationVersion,
SpecificationId = specificationId,
CalculationSpecification = new Reference("calc-spac-id", "calc spec name"),
FundingPeriod = new Reference("fp1", "fp 1"),
FundingStream = new Reference("fs1", "fs 1"),
Policies = new List <Reference> {
new Reference {
Id = "policy-1", Name = "policy 1"
}
}
}
};
IEnumerable <Models.Specs.Calculation> calculationSpecifications = new[]
{
new Models.Specs.Calculation
{
Id = "calc-spec-id"
}
};
BuildProject buildProject = new BuildProject();
Build build = new Build
{
SourceFiles = new List <SourceFile>()
};
Models.Specs.SpecificationSummary specificationSummary = new Models.Specs.SpecificationSummary();
ICalculationsRepository calculationsRepository = CreateCalculationsRepository();
calculationsRepository
.GetCalculationsBySpecificationId(Arg.Is(specificationId))
.Returns(calculations);
calculationsRepository
.UpdateCalculation(Arg.Any <Calculation>())
.Returns(HttpStatusCode.OK);
ISpecificationRepository specificationRepository = CreateSpecificationRepository();
specificationRepository
.GetCalculationSpecificationsForSpecification(Arg.Is(specificationId))
.Returns(calculationSpecifications);
specificationRepository
.GetSpecificationSummaryById(Arg.Is(specificationId))
.Returns(specificationSummary);
IBuildProjectsService buildProjectsService = CreateBuildProjectsService();
buildProjectsService
.GetBuildProjectForSpecificationId(Arg.Is(specificationId))
.Returns(buildProject);
ISourceCodeService sourceCodeService = CreateSourceCodeService();
sourceCodeService
.Compile(Arg.Is(buildProject), Arg.Any <IEnumerable <Calculation> >(), Arg.Any <CompilerOptions>())
.Returns(build);
IVersionRepository <CalculationVersion> calculationVersionRepository = CreateCalculationVersionRepository();
calculationVersionRepository
.CreateVersion(Arg.Any <CalculationVersion>(), Arg.Any <CalculationVersion>())
.Returns(calculationVersion);
ICacheProvider cacheProvider = CreateCacheProvider();
CalculationService calculationService = CreateCalculationService(
logger: logger,
calculationsRepository: calculationsRepository,
specificationRepository: specificationRepository,
buildProjectsService: buildProjectsService,
sourceCodeService: sourceCodeService,
calculationVersionRepository: calculationVersionRepository,
cacheProvider: cacheProvider);
//Act
await calculationService.ResetCalculationForFieldDefinitionChanges(relationships, specificationId, currentFieldDefinitionNames);
//Assert
await
sourceCodeService
.Received(1)
.DeleteAssembly(Arg.Is(specificationId));
await
cacheProvider
.Received(1)
.RemoveAsync <List <DatasetSchemaRelationshipModel> >(Arg.Is($"{CacheKeys.DatasetRelationshipFieldsForSpecification}{specificationId}"));
}
public async Task EditSpecification_GivenChangesAndSpecContainsPoliciesAndCalculations_UpdatesSearchAndSendsMessage()
{
//Arrange
SpecificationEditModel specificationEditModel = new SpecificationEditModel
{
FundingPeriodId = "fp10",
Name = "new spec name",
FundingStreamIds = new[] { "fs11" }
};
Period fundingPeriod = new Period
{
Id = "fp10",
Name = "fp 10"
};
IEnumerable <FundingStream> fundingStreams = new[]
{
new FundingStream {
AllocationLines = new List <AllocationLine>
{
new AllocationLine {
Id = "al1", Name = "al2"
}
}
}
};
string json = JsonConvert.SerializeObject(specificationEditModel);
byte[] byteArray = Encoding.UTF8.GetBytes(json);
MemoryStream stream = new MemoryStream(byteArray);
HttpContext context = Substitute.For <HttpContext>();
HttpRequest request = Substitute.For <HttpRequest>();
IQueryCollection queryStringValues = new QueryCollection(new Dictionary <string, StringValues>
{
{ "specificationId", new StringValues(SpecificationId) },
});
request
.Query
.Returns(queryStringValues);
request
.Body
.Returns(stream);
request
.HttpContext
.Returns(context);
ILogger logger = CreateLogger();
Specification specification = CreateSpecification();
specification
.Current
.Policies = new[]
{
new Policy
{
Calculations = new[]
{
new Calculation {
AllocationLine = new AllocationLine {
Id = "oldallocationlineid"
}
}
}
}
};
ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository();
specificationsRepository
.GetSpecificationById(Arg.Is(SpecificationId))
.Returns(specification);
specificationsRepository
.GetPeriodById(Arg.Is(fundingPeriod.Id))
.Returns(fundingPeriod);
specificationsRepository
.GetFundingStreams(Arg.Any <Expression <Func <FundingStream, bool> > >())
.Returns(fundingStreams);
specificationsRepository
.UpdateSpecification(Arg.Any <Specification>())
.Returns(HttpStatusCode.OK);
ISearchRepository <SpecificationIndex> searchRepository = CreateSearchRepository();
ICacheProvider cacheProvider = CreateCacheProvider();
IMessengerService messengerService = CreateMessengerService();
SpecificationVersion newSpecVersion = specification.Current.Clone() as SpecificationVersion;
newSpecVersion.Name = specificationEditModel.Name;
newSpecVersion.FundingPeriod.Id = specificationEditModel.FundingPeriodId;
newSpecVersion.FundingStreams = new[] { new FundingStream {
Id = "fs11"
} };
IVersionRepository <SpecificationVersion> versionRepository = CreateVersionRepository();
versionRepository
.CreateVersion(Arg.Any <SpecificationVersion>(), Arg.Any <SpecificationVersion>())
.Returns(newSpecVersion);
SpecificationsService service = CreateService(
logs: logger, specificationsRepository: specificationsRepository, searchRepository: searchRepository,
cacheProvider: cacheProvider, messengerService: messengerService, specificationVersionRepository: versionRepository);
//Act
IActionResult result = await service.EditSpecification(request);
//Arrange
await
searchRepository
.Received(1)
.Index(Arg.Is <IEnumerable <SpecificationIndex> >(
m => m.First().Id == SpecificationId &&
m.First().Name == "new spec name" &&
m.First().FundingPeriodId == "fp10" &&
m.First().FundingStreamIds.Count() == 1
));
await
cacheProvider
.Received(1)
.RemoveAsync <SpecificationSummary>(Arg.Is($"{CacheKeys.SpecificationSummaryById}{specification.Id}"));
await
messengerService
.Received(1)
.SendToTopic(Arg.Is(ServiceBusConstants.TopicNames.EditSpecification),
Arg.Is <SpecificationVersionComparisonModel>(
m => m.Id == SpecificationId &&
m.Current.Name == "new spec name" &&
m.Previous.Name == "Spec name"
), Arg.Any <IDictionary <string, string> >(), Arg.Is(true));
await
versionRepository
.Received(1)
.SaveVersion(Arg.Is(newSpecVersion));
}
public async Task EditSpecification_GivenChangesButFundingPeriodUnchanged_EnsuresCacheCorrectlyInvalidates()
{
//Arrange
SpecificationEditModel specificationEditModel = new SpecificationEditModel
{
FundingPeriodId = "FP1",
Name = "new spec name",
FundingStreamIds = new[] { "fs11" }
};
Period fundingPeriod = new Period
{
Id = "FP1",
Name = "fp 1"
};
IEnumerable <FundingStream> fundingStreams = new[]
{
new FundingStream()
};
string json = JsonConvert.SerializeObject(specificationEditModel);
byte[] byteArray = Encoding.UTF8.GetBytes(json);
MemoryStream stream = new MemoryStream(byteArray);
HttpContext context = Substitute.For <HttpContext>();
HttpRequest request = Substitute.For <HttpRequest>();
IQueryCollection queryStringValues = new QueryCollection(new Dictionary <string, StringValues>
{
{ "specificationId", new StringValues(SpecificationId) },
});
request
.Query
.Returns(queryStringValues);
request
.Body
.Returns(stream);
request
.HttpContext
.Returns(context);
ILogger logger = CreateLogger();
Specification specification = CreateSpecification();
ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository();
specificationsRepository
.GetSpecificationById(Arg.Is(SpecificationId))
.Returns(specification);
specificationsRepository
.GetPeriodById(Arg.Is(fundingPeriod.Id))
.Returns(fundingPeriod);
specificationsRepository
.GetFundingStreams(Arg.Any <Expression <Func <FundingStream, bool> > >())
.Returns(fundingStreams);
specificationsRepository
.UpdateSpecification(Arg.Any <Specification>())
.Returns(HttpStatusCode.OK);
ICacheProvider cacheProvider = CreateCacheProvider();
SpecificationVersion newSpecVersion = specification.Current.Clone() as SpecificationVersion;
IVersionRepository <SpecificationVersion> versionRepository = CreateVersionRepository();
versionRepository
.CreateVersion(Arg.Any <SpecificationVersion>(), Arg.Any <SpecificationVersion>())
.Returns(newSpecVersion);
SpecificationsService service = CreateService(
logs: logger, specificationsRepository: specificationsRepository, cacheProvider: cacheProvider, specificationVersionRepository: versionRepository);
//Act
IActionResult result = await service.EditSpecification(request);
//Arrange
await
cacheProvider
.Received(1)
.RemoveAsync <SpecificationSummary>(Arg.Is($"{CacheKeys.SpecificationSummaryById}{specification.Id}"));
await
cacheProvider
.DidNotReceive()
.RemoveAsync <List <SpecificationSummary> >(Arg.Is($"{CacheKeys.SpecificationSummariesByFundingPeriodId}fp1"));
await
versionRepository
.Received(1)
.SaveVersion(Arg.Is(newSpecVersion));
}
public async Task EditCalculation_WhenCalcInSubPolicyButNotTopLevelPolicyUpdatesCosmos_SendsMessageReturnsOk()
{
// Arrange
CalculationEditModel policyEditModel = new CalculationEditModel
{
Name = "new calc name",
CalculationType = CalculationType.Funding,
Description = "test description",
PolicyId = "policy-id-2"
};
string json = JsonConvert.SerializeObject(policyEditModel);
byte[] byteArray = Encoding.UTF8.GetBytes(json);
MemoryStream stream = new MemoryStream(byteArray);
HttpContext context = Substitute.For <HttpContext>();
HttpRequest request = Substitute.For <HttpRequest>();
IQueryCollection queryStringValues = new QueryCollection(new Dictionary <string, StringValues>
{
{ "specificationId", new StringValues(SpecificationId) },
{ "calculationId", new StringValues(CalculationId) },
});
request
.Query
.Returns(queryStringValues);
request
.Body
.Returns(stream);
request
.HttpContext
.Returns(context);
Specification specification = CreateSpecification();
specification
.Current
.Policies = new[] {
new Policy {
Id = PolicyId, Name = PolicyName, SubPolicies = new[] { new Policy {
Id = "policy-id-2", Name = "sub-policy", Calculations = new[] { new Calculation {
Id = CalculationId, Name = "Old name"
} }
} }
}
};
ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository();
specificationsRepository
.GetSpecificationById(Arg.Is(SpecificationId))
.Returns(specification);
specificationsRepository
.UpdateSpecification(Arg.Is(specification))
.Returns(HttpStatusCode.OK);
ICacheProvider cacheProvider = CreateCacheProvider();
IMessengerService messengerService = CreateMessengerService();
SpecificationVersion newSpecVersion = specification.Current.Clone() as SpecificationVersion;
newSpecVersion.Policies.First().SubPolicies.First().Calculations = new[] { new Calculation {
Id = CalculationId, Name = "new calc name"
} };
IVersionRepository <SpecificationVersion> versionRepository = CreateVersionRepository();
versionRepository
.CreateVersion(Arg.Any <SpecificationVersion>(), Arg.Any <SpecificationVersion>())
.Returns(newSpecVersion);
SpecificationsService specificationsService = CreateService(specificationsRepository: specificationsRepository,
cacheProvider: cacheProvider, messengerService: messengerService, specificationVersionRepository: versionRepository);
// Act
IActionResult result = await specificationsService.EditCalculation(request);
// Assert
result
.Should()
.BeOfType <OkObjectResult>();
specification
.Current
.Policies
.First()
.SubPolicies
.First()
.Calculations
.First()
.Name
.Should()
.Be("new calc name");
await
messengerService
.Received(1)
.SendToTopic(Arg.Is(ServiceBusConstants.TopicNames.EditCalculation),
Arg.Is <CalculationVersionComparisonModel>(
m => m.CalculationId == CalculationId &&
m.SpecificationId == SpecificationId
), Arg.Any <IDictionary <string, string> >());
await
versionRepository
.Received(1)
.SaveVersion(Arg.Is(newSpecVersion));
}
public async Task EditSpecification_WhenIndexingReturnsErrors_ShouldThrowException()
{
//Arrange
const string errorMessage = "Encountered error 802 code";
SpecificationEditModel specificationEditModel = new SpecificationEditModel
{
FundingPeriodId = "fp10",
Name = "new spec name",
FundingStreamIds = new[] { "fs11" }
};
Period fundingPeriod = new Period
{
Id = "fp10",
Name = "fp 10"
};
IEnumerable <FundingStream> fundingStreams = new[]
{
new FundingStream {
AllocationLines = new List <AllocationLine>
{
new AllocationLine {
Id = "al1", Name = "al2"
}
}
}
};
string json = JsonConvert.SerializeObject(specificationEditModel);
byte[] byteArray = Encoding.UTF8.GetBytes(json);
MemoryStream stream = new MemoryStream(byteArray);
HttpContext context = Substitute.For <HttpContext>();
HttpRequest request = Substitute.For <HttpRequest>();
IQueryCollection queryStringValues = new QueryCollection(new Dictionary <string, StringValues>
{
{ "specificationId", new StringValues(SpecificationId) },
});
request
.Query
.Returns(queryStringValues);
request
.Body
.Returns(stream);
request
.HttpContext
.Returns(context);
ILogger logger = CreateLogger();
Specification specification = CreateSpecification();
ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository();
specificationsRepository
.GetSpecificationById(Arg.Is(SpecificationId))
.Returns(specification);
specificationsRepository
.GetPeriodById(Arg.Is(fundingPeriod.Id))
.Returns(fundingPeriod);
specificationsRepository
.GetFundingStreams(Arg.Any <Expression <Func <FundingStream, bool> > >())
.Returns(fundingStreams);
specificationsRepository
.UpdateSpecification(Arg.Any <Specification>())
.Returns(HttpStatusCode.OK);
ISearchRepository <SpecificationIndex> searchRepository = CreateSearchRepository();
searchRepository
.Index(Arg.Any <IEnumerable <SpecificationIndex> >())
.Returns(new[] { new IndexError()
{
ErrorMessage = errorMessage
} });
ICacheProvider cacheProvider = CreateCacheProvider();
IMessengerService messengerService = CreateMessengerService();
SpecificationVersion newSpecVersion = specification.Current.Clone() as SpecificationVersion;
newSpecVersion.Name = specificationEditModel.Name;
newSpecVersion.FundingPeriod.Id = specificationEditModel.FundingPeriodId;
newSpecVersion.FundingStreams = new[] { new FundingStream {
Id = "fs11"
} };
IVersionRepository <SpecificationVersion> versionRepository = CreateVersionRepository();
versionRepository
.CreateVersion(Arg.Any <SpecificationVersion>(), Arg.Any <SpecificationVersion>())
.Returns(newSpecVersion);
SpecificationsService service = CreateService(
logs: logger, specificationsRepository: specificationsRepository, searchRepository: searchRepository,
cacheProvider: cacheProvider, messengerService: messengerService, specificationVersionRepository: versionRepository);
//Act
Func <Task <IActionResult> > editSpecification = async() => await service.EditSpecification(request);
//Assert
editSpecification
.Should()
.Throw <ApplicationException>()
.Which
.Message
.Should()
.Be($"Could not index specification {specification.Current.Id} because: {errorMessage}");
}
public async Task SetProfileVariationPointer_ValidParametersPassed_ReturnsOKAndSetsSetProfileVariationPointersOnSpec()
{
//Arrange
ILogger logger = CreateLogger();
string specificationId = "test";
Specification specification = new Specification
{
Current = new SpecificationVersion
{
ProfileVariationPointers = new ProfileVariationPointer[] { new ProfileVariationPointer
{
FundingLineId = "FundingLineId",
FundingStreamId = "FundingStreamId",
Occurrence = 1,
PeriodType = "PeriodType",
TypeValue = "TypeValue",
Year = 2019
},
new ProfileVariationPointer {
FundingLineId = "FundingLineId",
FundingStreamId = "FundingStreamId",
Occurrence = 2,
PeriodType = "PeriodType",
TypeValue = "TypeValue",
Year = 2019
} }
}
};
SpecificationProfileVariationPointerModel specificationProfileVariationPointerModel = new SpecificationProfileVariationPointerModel
{
FundingLineId = "FundingLineId",
FundingStreamId = "FundingStreamId",
Occurrence = 1,
PeriodType = "PeriodType",
TypeValue = "TypeValue",
Year = 2019
};
ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository();
IPoliciesApiClient policiesApiClient = CreatePoliciesApiClient();
IVersionRepository <SpecificationVersion> specificationVersionRepository = CreateSpecificationVersionRepository();
specificationsRepository
.GetSpecificationById(specificationId)
.Returns(specification);
SpecificationVersion clonedSpecificationVersion = null;
specificationVersionRepository.CreateVersion(Arg.Any <SpecificationVersion>(), Arg.Any <SpecificationVersion>())
.Returns(_ => (SpecificationVersion)_[0])
.AndDoes(_ => clonedSpecificationVersion = _.ArgAt <SpecificationVersion>(0));
specificationsRepository
.UpdateSpecification(Arg.Any <Specification>())
.Returns(HttpStatusCode.OK);
SpecificationsService service = CreateService(
logs: logger,
specificationsRepository: specificationsRepository,
specificationVersionRepository: specificationVersionRepository,
policiesApiClient: policiesApiClient);
// Act
IActionResult result = await service.SetProfileVariationPointer(specificationId, specificationProfileVariationPointerModel);
//Assert
result
.Should()
.BeOfType <OkObjectResult>()
.Which
.Value
.Should()
.Be(HttpStatusCode.OK);
specificationsRepository
.Received(1);
var profileVariationPointers = clonedSpecificationVersion?
.ProfileVariationPointers;
profileVariationPointers
.Should()
.NotBeNull()
.And.HaveCount(2)
.And.BeEquivalentTo(new ProfileVariationPointer[] { new ProfileVariationPointer
{
FundingLineId = "FundingLineId",
FundingStreamId = "FundingStreamId",
Occurrence = 1,
PeriodType = "PeriodType",
TypeValue = "TypeValue",
Year = 2019
},
new ProfileVariationPointer {
FundingLineId = "FundingLineId",
FundingStreamId = "FundingStreamId",
Occurrence = 2,
PeriodType = "PeriodType",
TypeValue = "TypeValue",
Year = 2019
} });
}
private async Task PersistDataset(TableLoadResult loadResult, Dataset dataset, DatasetDefinition datasetDefinition, BuildProject buildProject, string specificationId, string relationshipId, int version, Reference user)
{
IEnumerable <ProviderSummary> providerSummaries = await _providerService.FetchCoreProviderData();
Guard.IsNullOrWhiteSpace(relationshipId, nameof(relationshipId));
IList <ProviderSourceDataset> providerSourceDatasets = new List <ProviderSourceDataset>();
if (buildProject.DatasetRelationships == null)
{
_logger.Error($"No dataset relationships found for build project with id : '{buildProject.Id}' for specification '{specificationId}'");
return;
}
DatasetRelationshipSummary relationshipSummary = buildProject.DatasetRelationships.FirstOrDefault(m => m.Relationship.Id == relationshipId);
if (relationshipSummary == null)
{
_logger.Error($"No dataset relationship found for build project with id : {buildProject.Id} with data definition id {datasetDefinition.Id} and relationshipId '{relationshipId}'");
return;
}
ConcurrentDictionary <string, ProviderSourceDataset> existingCurrent = new ConcurrentDictionary <string, ProviderSourceDataset>();
IEnumerable <ProviderSourceDataset> existingCurrentDatasets = await _providerResultsRepositoryPolicy.ExecuteAsync(() =>
_providersResultsRepository.GetCurrentProviderSourceDatasets(specificationId, relationshipId));
if (existingCurrentDatasets.AnyWithNullCheck())
{
foreach (ProviderSourceDataset currentDataset in existingCurrentDatasets)
{
existingCurrent.TryAdd(currentDataset.ProviderId, currentDataset);
}
}
ConcurrentDictionary <string, ProviderSourceDataset> resultsByProviderId = new ConcurrentDictionary <string, ProviderSourceDataset>();
ConcurrentDictionary <string, ProviderSourceDataset> updateCurrentDatasets = new ConcurrentDictionary <string, ProviderSourceDataset>();
Parallel.ForEach(loadResult.Rows, (RowLoadResult row) =>
{
IEnumerable <string> allProviderIds = GetProviderIdsForIdentifier(datasetDefinition, row, providerSummaries);
foreach (string providerId in allProviderIds)
{
if (!resultsByProviderId.TryGetValue(providerId, out ProviderSourceDataset sourceDataset))
{
sourceDataset = new ProviderSourceDataset
{
DataGranularity = relationshipSummary.DataGranularity,
SpecificationId = specificationId,
DefinesScope = relationshipSummary.DefinesScope,
DataRelationship = new Reference(relationshipSummary.Relationship.Id, relationshipSummary.Relationship.Name),
DatasetRelationshipSummary = new Reference(relationshipSummary.Id, relationshipSummary.Name),
ProviderId = providerId
};
sourceDataset.Current = new ProviderSourceDatasetVersion
{
Rows = new List <Dictionary <string, object> >(),
Dataset = new VersionReference(dataset.Id, dataset.Name, version),
Date = DateTimeOffset.Now.ToLocalTime(),
ProviderId = providerId,
Version = 1,
PublishStatus = Models.Versioning.PublishStatus.Draft,
ProviderSourceDatasetId = sourceDataset.Id,
Author = user
};
if (!resultsByProviderId.TryAdd(providerId, sourceDataset))
{
resultsByProviderId.TryGetValue(providerId, out sourceDataset);
}
}
if (_featureToggle.IsUseFieldDefinitionIdsInSourceDatasetsEnabled())
{
sourceDataset.DataDefinitionId = relationshipSummary.DatasetDefinition.Id;
Dictionary <string, object> rows = new Dictionary <string, object>();
foreach (KeyValuePair <string, object> rowField in row.Fields)
{
foreach (TableDefinition tableDefinition in datasetDefinition.TableDefinitions)
{
FieldDefinition fieldDefinition = tableDefinition.FieldDefinitions.FirstOrDefault(m => m.Name == rowField.Key);
if (fieldDefinition != null)
{
rows.Add(fieldDefinition.Id, rowField.Value);
}
}
}
sourceDataset.Current.Rows.Add(rows);
}
else
{
sourceDataset.DataDefinition = new Reference(relationshipSummary.DatasetDefinition.Id, relationshipSummary.DatasetDefinition.Name);
sourceDataset.Current.Rows.Add(row.Fields);
}
}
});
ConcurrentBag <ProviderSourceDatasetVersion> historyToSave = new ConcurrentBag <ProviderSourceDatasetVersion>();
List <Task> historySaveTasks = new List <Task>(resultsByProviderId.Count);
SemaphoreSlim throttler = new SemaphoreSlim(initialCount: 15);
foreach (KeyValuePair <string, ProviderSourceDataset> providerSourceDataset in resultsByProviderId)
{
await throttler.WaitAsync();
historySaveTasks.Add(
Task.Run(async() =>
{
try
{
string providerId = providerSourceDataset.Key;
ProviderSourceDataset sourceDataset = providerSourceDataset.Value;
ProviderSourceDatasetVersion newVersion = null;
if (existingCurrent.ContainsKey(providerId))
{
newVersion = existingCurrent[providerId].Current.Clone() as ProviderSourceDatasetVersion;
string existingDatasetJson = JsonConvert.SerializeObject(existingCurrent[providerId].Current.Rows);
string latestDatasetJson = JsonConvert.SerializeObject(sourceDataset.Current.Rows);
if (existingDatasetJson != latestDatasetJson)
{
newVersion = await _sourceDatasetsVersionRepository.CreateVersion(newVersion, existingCurrent[providerId].Current, providerId);
newVersion.Author = user;
newVersion.Rows = sourceDataset.Current.Rows;
sourceDataset.Current = newVersion;
updateCurrentDatasets.TryAdd(providerId, sourceDataset);
historyToSave.Add(newVersion);
}
existingCurrent.TryRemove(providerId, out ProviderSourceDataset existingProviderSourceDataset);
}
else
{
newVersion = sourceDataset.Current;
updateCurrentDatasets.TryAdd(providerId, sourceDataset);
historyToSave.Add(newVersion);
}
}
finally
{
throttler.Release();
}
}));
}
await TaskHelper.WhenAllAndThrow(historySaveTasks.ToArray());
if (updateCurrentDatasets.Count > 0)
{
_logger.Information($"Saving {updateCurrentDatasets.Count()} updated source datasets");
await _providerResultsRepositoryPolicy.ExecuteAsync(() =>
_providersResultsRepository.UpdateCurrentProviderSourceDatasets(updateCurrentDatasets.Values));
}
if (_featureToggle.IsProviderResultsSpecificationCleanupEnabled() && existingCurrent.Any())
{
_logger.Information($"Removing {existingCurrent.Count()} missing source datasets");
await _providerResultsRepositoryPolicy.ExecuteAsync(() =>
_providersResultsRepository.DeleteCurrentProviderSourceDatasets(existingCurrent.Values));
foreach (IEnumerable <ProviderSourceDataset> providerSourceDataSets in existingCurrent.Values.Partition <ProviderSourceDataset>(1000))
{
await SendProviderSourceDatasetCleanupMessageToTopic(specificationId, ServiceBusConstants.TopicNames.ProviderSourceDatasetCleanup, providerSourceDataSets);
}
}
if (historyToSave.Any())
{
_logger.Information($"Saving {historyToSave.Count()} items to history");
await _sourceDatasetsVersionRepository.SaveVersions(historyToSave);
}
Reference relationshipReference = new Reference(relationshipSummary.Relationship.Id, relationshipSummary.Relationship.Name);
DatasetAggregations datasetAggregations = GenerateAggregations(datasetDefinition, loadResult, specificationId, relationshipReference);
if (!datasetAggregations.Fields.IsNullOrEmpty())
{
await _datasetsAggregationsRepository.CreateDatasetAggregations(datasetAggregations);
}
await _cacheProvider.RemoveAsync <List <CalculationAggregation> >($"{CacheKeys.DatasetAggregationsForSpecification}{specificationId}");
await PopulateProviderSummariesForSpecification(specificationId, providerSummaries);
}
public async Task <IActionResult> SaveVersion(HttpRequest request)
{
string json = await request.GetRawBodyStringAsync();
CreateNewTestScenarioVersion scenarioVersion = JsonConvert.DeserializeObject <CreateNewTestScenarioVersion>(json);
if (scenarioVersion == null)
{
_logger.Error("A null scenario version was provided");
return(new BadRequestObjectResult("Null or empty calculation Id provided"));
}
BadRequestObjectResult validationResult = (await _createNewTestScenarioVersionValidator.ValidateAsync(scenarioVersion)).PopulateModelState();
if (validationResult != null)
{
return(validationResult);
}
TestScenario testScenario = null;
if (!string.IsNullOrEmpty(scenarioVersion.Id))
{
testScenario = await _scenariosRepository.GetTestScenarioById(scenarioVersion.Id);
}
bool saveAsVersion = true;
SpecificationSummary specification = await _specificationsRepository.GetSpecificationSummaryById(scenarioVersion.SpecificationId);
if (specification == null)
{
_logger.Error($"Unable to find a specification for specification id : {scenarioVersion.SpecificationId}");
return(new StatusCodeResult(412));
}
Reference user = request.GetUserOrDefault();
if (testScenario == null)
{
string Id = Guid.NewGuid().ToString();
testScenario = new TestScenario
{
Id = Id,
SpecificationId = specification.Id,
Name = scenarioVersion.Name,
Current = new TestScenarioVersion
{
Date = DateTimeOffset.Now.ToLocalTime(),
TestScenarioId = Id,
PublishStatus = PublishStatus.Draft,
Version = 1,
Author = user,
Gherkin = scenarioVersion.Scenario,
Description = scenarioVersion.Description,
FundingPeriodId = specification.FundingPeriod.Id,
FundingStreamIds = specification.FundingStreams.Select(s => s.Id).ToArraySafe(),
}
};
}
else
{
testScenario.Name = scenarioVersion.Name;
saveAsVersion = !string.Equals(scenarioVersion.Scenario, testScenario.Current.Gherkin) ||
scenarioVersion.Description != testScenario.Current.Description;
TestScenarioVersion newVersion = testScenario.Current.Clone() as TestScenarioVersion;
if (saveAsVersion == true)
{
newVersion.Author = user;
newVersion.Gherkin = scenarioVersion.Scenario;
newVersion.Description = scenarioVersion.Description;
newVersion.FundingStreamIds = specification.FundingStreams.Select(s => s.Id).ToArraySafe();
newVersion.FundingPeriodId = specification.FundingPeriod.Id;
newVersion = await _versionRepository.CreateVersion(newVersion, testScenario.Current);
testScenario.Current = newVersion;
}
}
HttpStatusCode statusCode = await _scenariosRepository.SaveTestScenario(testScenario);
if (!statusCode.IsSuccess())
{
_logger.Error($"Failed to save test scenario with status code: {statusCode.ToString()}");
return(new StatusCodeResult((int)statusCode));
}
await _versionRepository.SaveVersion(testScenario.Current);
ScenarioIndex scenarioIndex = CreateScenarioIndexFromScenario(testScenario, specification);
await _searchRepository.Index(new List <ScenarioIndex> {
scenarioIndex
});
await _cacheProvider.RemoveAsync <List <TestScenario> >($"{CacheKeys.TestScenarios}{testScenario.SpecificationId}");
await _cacheProvider.RemoveAsync <GherkinParseResult>($"{CacheKeys.GherkinParseResult}{testScenario.Id}");
IEnumerable <Models.Calcs.CalculationCurrentVersion> calculations = await _calcsRepositoryPolicy.ExecuteAsync(() => _calcsRepository.GetCurrentCalculationsBySpecificationId(specification.Id));
if (calculations.IsNullOrEmpty())
{
_logger.Information($"No calculations found to test for specification id: '{specification.Id}'");
}
else
{
string correlationId = request.GetCorrelationId();
try
{
Trigger trigger = new Trigger
{
EntityId = testScenario.Id,
EntityType = nameof(TestScenario),
Message = $"Saving test scenario: '{testScenario.Id}'"
};
bool generateCalculationAggregations = SourceCodeHelpers.HasCalculationAggregateFunctionParameters(calculations.Select(m => m.SourceCode));
Job job = await SendInstructAllocationsToJobService(specification.Id, user, trigger, correlationId, generateCalculationAggregations);
_logger.Information($"New job of type '{job.JobDefinitionId}' created with id: '{job.Id}'");
}
catch (Exception ex)
{
_logger.Error(ex, $"Failed to create job of type '{JobConstants.DefinitionNames.CreateInstructAllocationJob}' on specification '{specification.Id}'");
return(new InternalServerErrorResult($"An error occurred attempting to execute calculations prior to running tests on specification '{specification.Id}'"));
}
}
CurrentTestScenario testScenarioResult = await _scenariosRepository.GetCurrentTestScenarioById(testScenario.Id);
return(new OkObjectResult(testScenarioResult));
}
public async Task EditPolicy_WhenPolicyASubPolicyForOnePolicyButSubPolicyOfAnotherPolicy_SavesChanges()
{
// Arrange
PolicyEditModel policyEditModel = new PolicyEditModel
{
SpecificationId = SpecificationId,
Name = "new policy name",
Description = "new policy description",
ParentPolicyId = "new-parent-policy-id"
};
string json = JsonConvert.SerializeObject(policyEditModel);
byte[] byteArray = Encoding.UTF8.GetBytes(json);
MemoryStream stream = new MemoryStream(byteArray);
HttpContext context = Substitute.For <HttpContext>();
HttpRequest request = Substitute.For <HttpRequest>();
IQueryCollection queryStringValues = new QueryCollection(new Dictionary <string, StringValues>
{
{ "specificationId", new StringValues(SpecificationId) },
{ "policyId", new StringValues(PolicyId) },
});
request
.Query
.Returns(queryStringValues);
request
.Body
.Returns(stream);
request
.HttpContext
.Returns(context);
Specification specification = CreateSpecification();
specification
.Current
.Policies = new[]
{
new Policy
{
Id = "parent-policy-id",
Name = "policy name",
SubPolicies = new[] { new Policy {
Id = PolicyId, Name = PolicyName
} }
},
new Policy
{
Id = "new-parent-policy-id",
Name = "policy name",
SubPolicies = Enumerable.Empty <Policy>()
}
};
ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository();
specificationsRepository
.GetSpecificationById(Arg.Is(SpecificationId))
.Returns(specification);
specificationsRepository
.UpdateSpecification(Arg.Is(specification))
.Returns(HttpStatusCode.OK);
IMessengerService messengerService = CreateMessengerService();
SpecificationVersion newSpecVersion = specification.Current.Clone() as SpecificationVersion;
newSpecVersion.Policies.Last().SubPolicies = newSpecVersion.Policies.Last().SubPolicies.Concat(new[] { specification.Current.Policies.First().SubPolicies.First() });
newSpecVersion.Policies.First().SubPolicies = Enumerable.Empty <Policy>();
IVersionRepository <SpecificationVersion> versionRepository = CreateVersionRepository();
versionRepository
.CreateVersion(Arg.Any <SpecificationVersion>(), Arg.Any <SpecificationVersion>())
.Returns(newSpecVersion);
SpecificationsService specificationsService = CreateService(specificationsRepository: specificationsRepository,
messengerService: messengerService, specificationVersionRepository: versionRepository);
// Act
IActionResult result = await specificationsService.EditPolicy(request);
// Assert
result
.Should()
.BeOfType <OkObjectResult>();
specification
.Current
.Policies
.Count()
.Should()
.Be(2);
specification
.Current
.Policies
.First()
.SubPolicies
.Any()
.Should()
.BeFalse();
specification
.Current
.Policies
.Last()
.SubPolicies
.Any()
.Should()
.BeTrue();
}
public async Task UpdateCalculationCodeOnCalculationChange_WhenNoCalculationsFoundReferencingCalculationToBeUpdated_ThenNoCalculationsUpdated()
{
// Arrange
ICalculationsRepository calculationsRepository = CreateCalculationsRepository();
ISpecificationsApiClient specificationsApiClient = CreateSpecificationsApiClient();
IVersionRepository <CalculationVersion> versionRepository = CreateCalculationVersionRepository();
CalculationService service = CreateCalculationService(calculationsRepository: calculationsRepository,
specificationsApiClient: specificationsApiClient,
calculationVersionRepository: versionRepository);
const string specificationId = "specId";
const string calculationId = "updatedCalc";
CalculationVersionComparisonModel comparison = new CalculationVersionComparisonModel()
{
CalculationId = calculationId,
CurrentName = "Calculation To Update",
PreviousName = "Original Name",
SpecificationId = specificationId,
};
Reference user = new Reference("userId", "User Name");
List <Calculation> calculations = new List <Calculation>()
{
new Calculation
{
Id = calculationId,
SpecificationId = specificationId,
Current = new CalculationVersion
{
SourceCode = "Return 10",
Name = "Calculation to Update",
CalculationType = CalculationType.Template,
Description = "Calculation Description"
}
},
new Calculation
{
Id = "referenceCalc",
SpecificationId = specificationId,
Current = new CalculationVersion
{
SourceCode = "Return 50",
Name = "Calling Calculation To Update",
CalculationType = CalculationType.Template,
Description = "Calculation Description",
}
}
};
calculationsRepository
.GetCalculationsBySpecificationId(Arg.Is(specificationId))
.Returns(calculations);
calculationsRepository
.UpdateCalculation(Arg.Any <Calculation>())
.Returns(HttpStatusCode.OK);
calculationsRepository
.GetCalculationById(Arg.Is(calculations[0].Id))
.Returns(calculations[0]);
SpecModel.SpecificationSummary specification = new SpecModel.SpecificationSummary()
{
Id = specificationId,
Name = "Specification Name",
};
specificationsApiClient
.GetSpecificationSummaryById(Arg.Is(specificationId))
.Returns(new Common.ApiClient.Models.ApiResponse <SpecModel.SpecificationSummary>(HttpStatusCode.OK, specification));
CalculationVersion calculationVersion = new CalculationVersion
{
SourceCode = "Return CalculationToUpdate()",
Version = 2
};
versionRepository
.CreateVersion(Arg.Any <CalculationVersion>(), Arg.Any <CalculationVersion>())
.Returns(calculationVersion);
// Act
IEnumerable <Calculation> updatedCalculations = await service.UpdateCalculationCodeOnCalculationChange(comparison, user);
// Assert
updatedCalculations
.Should()
.HaveCount(0);
}
public async Task SetPublishDates_ValidParametersPassed_ReturnsOKAndSetsPublishedDatesOnSpec()
{
//Arrange
ILogger logger = CreateLogger();
string specificationId = "test";
DateTimeOffset?earliestPublicationDateInput = NewRandomDateTimeOffset();
DateTimeOffset?earliestPaymentDateInput = NewRandomDateTimeOffset();
Specification specification = new Specification
{
Current = new SpecificationVersion
{
ExternalPublicationDate = DateTimeOffset.Now,
EarliestPaymentAvailableDate = DateTimeOffset.Now
}
};
SpecificationPublishDateModel specificationPublishDateModel = new SpecificationPublishDateModel()
{
EarliestPaymentAvailableDate = earliestPaymentDateInput,
ExternalPublicationDate = earliestPublicationDateInput
};
IVersionRepository <SpecificationVersion> specificationVersionRepository = CreateSpecificationVersionRepository();
specificationsRepository
.GetSpecificationById(specificationId)
.Returns(specification);
SpecificationVersion clonedSpecificationVersion = null;
specificationVersionRepository.CreateVersion(Arg.Any <SpecificationVersion>(), Arg.Any <SpecificationVersion>())
.Returns(_ => (SpecificationVersion)_[0])
.AndDoes(_ => clonedSpecificationVersion = _.ArgAt <SpecificationVersion>(0));
specificationsRepository
.UpdateSpecification(Arg.Any <Specification>())
.Returns(HttpStatusCode.OK);
SpecificationsService service = CreateService(
logs: logger,
specificationsRepository: specificationsRepository,
specificationVersionRepository: specificationVersionRepository,
policiesApiClient: policiesApiClient);
// Act
IActionResult result = await service.SetPublishDates(specificationId, specificationPublishDateModel);
//Assert
result
.Should()
.BeOfType <OkObjectResult>()
.Which
.Value
.Should()
.Be(HttpStatusCode.OK);
specificationsRepository
.Received(1);
(clonedSpecificationVersion?
.ExternalPublicationDate)
.Should()
.Be(earliestPublicationDateInput.TrimToTheMinute());
(clonedSpecificationVersion?
.EarliestPaymentAvailableDate)
.Should()
.Be(earliestPaymentDateInput.TrimToTheMinute());
}
public async Task UpdateCalculationCodeOnCalculationChange_WhenCalculationsFoundReferencingCalculationToBeUpdated_ThenSourceCodeUpdated()
{
// Arrange
ICalculationsRepository calculationsRepository = CreateCalculationsRepository();
ISpecificationsApiClient specificationsApiClient = CreateSpecificationsApiClient();
IVersionRepository <CalculationVersion> versionRepository = CreateCalculationVersionRepository();
IBuildProjectsService buildProjectsService = CreateBuildProjectsService();
ISourceCodeService sourceCodeService = CreateSourceCodeService();
CalculationService service = CreateCalculationService(calculationsRepository: calculationsRepository,
specificationsApiClient: specificationsApiClient,
calculationVersionRepository: versionRepository,
buildProjectsService: buildProjectsService,
sourceCodeService: sourceCodeService);
const string specificationId = "specId";
const string calculationId = "updatedCalc";
const string originalCodeUpdate = @"Dim test as OriginalNameOptions?
OriginalNameOptions.enumName
Return Calculations.OriginalName()";
const string newCodeUpdated = @"Dim test as CalculationToUpdateOptions?
CalculationToUpdateOptions.enumName
Return Calculations.CalculationToUpdate()";
const string originalCodeIgnore = "Return 10";
const string fundingStreamId = "fundingstreamid";
CalculationVersionComparisonModel comparison = new CalculationVersionComparisonModel()
{
CalculationId = calculationId,
CurrentName = "Calculation To Update",
PreviousName = "Original Name",
SpecificationId = specificationId,
CalculationDataType = CalculationDataType.Enum,
Namespace = "Calculations"
};
Reference user = new Reference("userId", "User Name");
List <Calculation> calculations = new List <Calculation>
{
new Calculation
{
Id = calculationId,
SpecificationId = specificationId,
FundingStreamId = fundingStreamId,
Current = new CalculationVersion
{
SourceCode = originalCodeIgnore,
Name = "Calculation to Update",
CalculationType = CalculationType.Template,
Description = "Calculation Description",
DataType = CalculationDataType.Enum
}
},
new Calculation
{
Id = "referenceCalc",
SpecificationId = specificationId,
FundingStreamId = fundingStreamId,
Current = new CalculationVersion
{
SourceCode = originalCodeUpdate,
Name = "Calling Calculation To Update",
CalculationType = CalculationType.Template,
Description = "Calculation Description"
}
}
};
calculationsRepository
.GetCalculationsBySpecificationId(Arg.Is(specificationId))
.Returns(calculations);
calculationsRepository
.UpdateCalculation(Arg.Any <Calculation>())
.Returns(HttpStatusCode.OK);
calculationsRepository
.GetCalculationById(Arg.Is(calculations[0].Id))
.Returns(calculations[0]);
SpecModel.SpecificationSummary specification = new SpecModel.SpecificationSummary()
{
Id = specificationId,
Name = "Specification Name",
FundingStreams = new [] { new Reference(fundingStreamId, "fundingStreamName"), }
};
specificationsApiClient
.GetSpecificationSummaryById(Arg.Is(specificationId))
.Returns(new Common.ApiClient.Models.ApiResponse <SpecModel.SpecificationSummary>(HttpStatusCode.OK, specification));
CalculationVersion calculationVersion = new CalculationVersion
{
SourceCode = newCodeUpdated,
Version = 2
};
versionRepository
.CreateVersion(Arg.Is <CalculationVersion>(_ => _.SourceCode == newCodeUpdated), Arg.Any <CalculationVersion>())
.Returns(calculationVersion);
buildProjectsService
.GetBuildProjectForSpecificationId(specificationId)
.Returns(new BuildProject());
sourceCodeService
.Compile(Arg.Any <BuildProject>(), Arg.Any <IEnumerable <Calculation> >(), Arg.Any <CompilerOptions>())
.Returns(new Build());
// Act
IEnumerable <Calculation> updatedCalculations = await service.UpdateCalculationCodeOnCalculationChange(comparison, user);
// Assert
updatedCalculations
.Should()
.HaveCount(1);
Calculation calculation = updatedCalculations.Single();
calculation.Current.SourceCode
.Should()
.Be(newCodeUpdated);
calculation.Current.Version
.Should()
.Be(2);
calculation.Id
.Should()
.Be("referenceCalc");
}
public async Task EditCalculationStatus_GivenNewStatusOfUpdated_UpdatesSearchReturnsOK()
{
//Arrange
EditStatusModel CalculationEditStatusModel = new EditStatusModel
{
PublishStatus = PublishStatus.Updated
};
ILogger logger = CreateLogger();
Calculation calculation = CreateCalculation();
calculation.Current.PublishStatus = PublishStatus.Approved;
CalculationVersion calculationVersion = calculation.Current.Clone() as CalculationVersion;
calculationVersion.PublishStatus = PublishStatus.Updated;
ICalculationsRepository CalculationsRepository = CreateCalculationsRepository();
CalculationsRepository
.GetCalculationById(Arg.Is(CalculationId))
.Returns(calculation);
CalculationsRepository
.UpdateCalculation(Arg.Any <Calculation>())
.Returns(HttpStatusCode.OK);
ISearchRepository <CalculationIndex> searchRepository = CreateSearchRepository();
SpecModel.SpecificationSummary specificationSummary = new SpecModel.SpecificationSummary()
{
Id = calculation.SpecificationId,
Name = "spec name",
FundingStreams = new[]
{
new Reference(calculation.FundingStreamId, "funding stream name")
}
};
ISpecificationsApiClient specificationsApiClient = CreateSpecificationsApiClient();
specificationsApiClient
.GetSpecificationSummaryById(Arg.Is(calculation.SpecificationId))
.Returns(new Common.ApiClient.Models.ApiResponse <SpecModel.SpecificationSummary>(HttpStatusCode.OK, specificationSummary));
IVersionRepository <CalculationVersion> versionRepository = CreateCalculationVersionRepository();
versionRepository
.CreateVersion(Arg.Any <CalculationVersion>(), Arg.Any <CalculationVersion>())
.Returns(calculationVersion);
Build build = new Build
{
SourceFiles = new List <SourceFile> {
new SourceFile()
}
};
BuildProject buildProject = new BuildProject();
IBuildProjectsService buildProjectsService = CreateBuildProjectsService();
buildProjectsService
.GetBuildProjectForSpecificationId(Arg.Is(calculation.SpecificationId))
.Returns(buildProject);
ISourceCodeService sourceCodeService = CreateSourceCodeService();
sourceCodeService
.Compile(Arg.Any <BuildProject>(), Arg.Any <IEnumerable <Models.Calcs.Calculation> >(), Arg.Any <CompilerOptions>())
.Returns(build);
CalculationService service = CreateCalculationService(
logger: logger, calculationsRepository: CalculationsRepository, searchRepository: searchRepository,
specificationsApiClient: specificationsApiClient, calculationVersionRepository: versionRepository,
sourceCodeService: sourceCodeService, buildProjectsService: buildProjectsService);
//Act
IActionResult result = await service.UpdateCalculationStatus(CalculationId, CalculationEditStatusModel);
//Arrange
result
.Should()
.BeOfType <OkObjectResult>()
.Which
.Value
.Should()
.BeOfType <PublishStatusResultModel>()
.Which
.PublishStatus
.Should()
.Be(PublishStatus.Updated);
calculation
.Current
.PublishStatus
.Should()
.Be(PublishStatus.Updated);
}
public async Task UpdateCalculationCodeOnCalculationSpecificationChange_WhenNoCalculationsFoundReferencingCalculationToBeUpdated_ThenNoCalculationsUpdated()
{
// Arrange
ICalculationsRepository calculationsRepository = CreateCalculationsRepository();
ISpecificationRepository specificationRepository = CreateSpecificationRepository();
IVersionRepository <CalculationVersion> versionRepository = CreateCalculationVersionRepository();
ICalculationCodeReferenceUpdate calculationCodeReferenceUpdate = FakeCalculationCodeReferenceUpdate();
CalculationService service = CreateCalculationService(calculationsRepository: calculationsRepository,
specificationRepository: specificationRepository,
calculationVersionRepository: versionRepository,
calculationCodeReferenceUpdate: calculationCodeReferenceUpdate);
const string specificationId = "specId";
const string calculationId = "updatedCalc";
Models.Specs.CalculationVersionComparisonModel comparison = new Models.Specs.CalculationVersionComparisonModel()
{
CalculationId = calculationId,
Current = new Models.Specs.Calculation
{
Id = "calcSpec1",
Name = "Calculation to update",
CalculationType = Models.Specs.CalculationType.Funding,
},
Previous = new Models.Specs.Calculation
{
Id = "calcSpec1",
Name = "Original Name",
CalculationType = Models.Specs.CalculationType.Funding,
},
SpecificationId = specificationId,
};
Reference user = new Reference("userId", "User Name");
List <Calculation> calculations = new List <Calculation>()
{
new Calculation
{
Id = calculationId,
Name = "Calculation to Update",
SpecificationId = specificationId,
FundingPeriod = new Reference("fp1", "Funding Period"),
CalculationSpecification = new Reference("calcSpec1", "Calculation to Update"),
CalculationType = CalculationType.Funding,
Description = "Calculation Description",
BuildProjectId = "bpC1",
Policies = new List <Reference>(),
Current = new CalculationVersion
{
SourceCode = "Return 10",
DecimalPlaces = 6,
}
},
new Calculation
{
Id = "referenceCalc",
Name = "Calling Calculation To Update",
SpecificationId = specificationId,
FundingPeriod = new Reference("fp1", "Funding Period"),
CalculationSpecification = new Reference("calcSpec1", "Calculation to Update"),
CalculationType = CalculationType.Funding,
Description = "Calculation Description",
BuildProjectId = "bpC1",
Policies = new List <Reference>(),
Current = new CalculationVersion
{
SourceCode = "Return 50",
DecimalPlaces = 6,
}
}
};
calculationsRepository
.GetCalculationsBySpecificationId(Arg.Is(specificationId))
.Returns(calculations);
calculationsRepository
.UpdateCalculation(Arg.Any <Calculation>())
.Returns(HttpStatusCode.OK);
calculationsRepository
.GetCalculationById(Arg.Is(calculations[0].Id))
.Returns(calculations[0]);
Models.Specs.SpecificationSummary specification = new Models.Specs.SpecificationSummary()
{
Id = specificationId,
Name = "Specification Name",
};
specificationRepository
.GetSpecificationSummaryById(Arg.Is(specificationId))
.Returns(specification);
CalculationVersion calculationVersion = new CalculationVersion
{
SourceCode = "Return CalculationToUpdate()",
Version = 2
};
versionRepository
.CreateVersion(Arg.Any <CalculationVersion>(), Arg.Any <CalculationVersion>())
.Returns(calculationVersion);
// Act
IEnumerable <Calculation> updatedCalculations = await service.UpdateCalculationCodeOnCalculationSpecificationChange(comparison, user);
// Assert
updatedCalculations
.Should()
.HaveCount(0);
calculationCodeReferenceUpdate
.Received(calculations.Count)
.ReplaceSourceCodeReferences(Arg.Any <string>(),
VisualBasicTypeGenerator.GenerateIdentifier(comparison.Previous.Name),
VisualBasicTypeGenerator.GenerateIdentifier(comparison.Current.Name));
foreach (Calculation calculation in calculations)
{
calculationCodeReferenceUpdate
.Received(1)
.ReplaceSourceCodeReferences(calculation.Current.SourceCode,
VisualBasicTypeGenerator.GenerateIdentifier(comparison.Previous.Name),
VisualBasicTypeGenerator.GenerateIdentifier(comparison.Current.Name));
}
}
public async Task EditCalculation_WhenRenameCalculationToBrandNew_ReturnsOk()
{
// Arrange
CalculationEditModel policyEditModel = new CalculationEditModel
{
Name = "new calc name",
CalculationType = CalculationType.Funding,
Description = "test description",
PolicyId = "policy-id-2"
};
string json = JsonConvert.SerializeObject(policyEditModel);
byte[] byteArray = Encoding.UTF8.GetBytes(json);
MemoryStream stream = new MemoryStream(byteArray);
HttpContext context = Substitute.For <HttpContext>();
HttpRequest request = Substitute.For <HttpRequest>();
IQueryCollection queryStringValues = new QueryCollection(new Dictionary <string, StringValues>
{
{ "specificationId", new StringValues(SpecificationId) },
{ "calculationId", new StringValues(CalculationId) },
});
request
.Query
.Returns(queryStringValues);
request
.Body
.Returns(stream);
request
.HttpContext
.Returns(context);
Specification specification = CreateSpecification();
specification
.Current
.Policies = new[] {
new Policy {
Id = PolicyId, Name = PolicyName, SubPolicies = new[] { new Policy {
Id = "policy-id-2", Name = "sub-policy", Calculations = new[] { new Calculation {
Id = CalculationId, Name = "Old name"
} }
} }
}
};
ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository();
specificationsRepository
.GetSpecificationById(Arg.Is(SpecificationId))
.Returns(specification);
specificationsRepository
.UpdateSpecification(Arg.Is(specification))
.Returns(HttpStatusCode.OK);
SpecificationVersion newSpecVersion = specification.Current.Clone() as SpecificationVersion;
newSpecVersion.Policies.First().SubPolicies.First().Calculations = new[] { new Calculation {
Id = CalculationId, Name = "new calc name"
} };
IVersionRepository <SpecificationVersion> versionRepository = CreateVersionRepository();
versionRepository
.CreateVersion(Arg.Any <SpecificationVersion>(), Arg.Any <SpecificationVersion>())
.Returns(newSpecVersion);
ICalculationsRepository calculationsRepository = CreateCalculationsRepository();
calculationsRepository
.IsCalculationNameValid(Arg.Is(SpecificationId), Arg.Is("new calc name"), Arg.Is(CalculationId))
.Returns(true);
SpecificationsService specificationsService = CreateService(specificationsRepository: specificationsRepository,
specificationVersionRepository: versionRepository);
// Act
IActionResult result = await specificationsService.EditCalculation(request);
// Assert
result
.Should()
.BeOfType <OkObjectResult>();
await
versionRepository
.Received(1)
.SaveVersion(Arg.Is(newSpecVersion));
}
public void EditCalculation_WhenSomethingGoesWrongDuringIndexing_ShouldThrowException()
{
// Arrange
const string errorMessage = "Encountered error 802";
CalculationEditModel policyEditModel = new CalculationEditModel
{
Name = "new calc name",
CalculationType = CalculationType.Funding,
Description = "test description",
PolicyId = "policy-id-2"
};
string json = JsonConvert.SerializeObject(policyEditModel);
byte[] byteArray = Encoding.UTF8.GetBytes(json);
MemoryStream stream = new MemoryStream(byteArray);
HttpContext context = Substitute.For <HttpContext>();
HttpRequest request = Substitute.For <HttpRequest>();
IQueryCollection queryStringValues = new QueryCollection(new Dictionary <string, StringValues>
{
{ "specificationId", new StringValues(SpecificationId) },
{ "calculationId", new StringValues(CalculationId) },
});
request
.Query
.Returns(queryStringValues);
request
.Body
.Returns(stream);
request
.HttpContext
.Returns(context);
Specification specification = CreateSpecification();
specification
.Current
.Policies = new[] {
new Policy {
Id = PolicyId, Name = PolicyName, Calculations = new[] { new Calculation {
Id = CalculationId, Name = "Old name"
} }
},
new Policy {
Id = "policy-id-2", Name = PolicyName
}
};
ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository();
specificationsRepository
.GetSpecificationById(Arg.Is(SpecificationId))
.Returns(specification);
specificationsRepository
.UpdateSpecification(Arg.Is(specification))
.Returns(HttpStatusCode.OK);
ICacheProvider cacheProvider = CreateCacheProvider();
IMessengerService messengerService = CreateMessengerService();
SpecificationVersion newSpecVersion = specification.Current.Clone() as SpecificationVersion;
newSpecVersion.Policies.ElementAt(1).Calculations = new[] { new Calculation {
Id = CalculationId, Name = "new calc name"
} };
IVersionRepository <SpecificationVersion> versionRepository = CreateVersionRepository();
versionRepository
.CreateVersion(Arg.Any <SpecificationVersion>(), Arg.Any <SpecificationVersion>())
.Returns(newSpecVersion);
ISearchRepository <SpecificationIndex> mockSearchRepository = CreateSearchRepository();
mockSearchRepository
.Index(Arg.Any <IEnumerable <SpecificationIndex> >())
.Returns(new List <IndexError>()
{
new IndexError()
{
ErrorMessage = errorMessage
}
});
SpecificationsService specificationsService = CreateService(specificationsRepository: specificationsRepository,
cacheProvider: cacheProvider, messengerService: messengerService, specificationVersionRepository: versionRepository, searchRepository: mockSearchRepository);
//Act
Func <Task <IActionResult> > editSpecification = async() => await specificationsService.EditCalculation(request);
//Assert
editSpecification
.Should()
.Throw <ApplicationException>()
.Which
.Message
.Should()
.Be($"Could not index specification {specification.Current.Id} because: {errorMessage}");
}
public async Task EditPolicy_WhenValidModelAndUpdateCosmosAndIsASubPolicy_SendsMessageAndReturnsOK()
{
// Arrange
PolicyEditModel policyEditModel = new PolicyEditModel
{
SpecificationId = SpecificationId,
Name = "new policy name",
Description = "new policy description",
ParentPolicyId = "parent-policy-id"
};
string json = JsonConvert.SerializeObject(policyEditModel);
byte[] byteArray = Encoding.UTF8.GetBytes(json);
MemoryStream stream = new MemoryStream(byteArray);
HttpContext context = Substitute.For <HttpContext>();
HttpRequest request = Substitute.For <HttpRequest>();
IQueryCollection queryStringValues = new QueryCollection(new Dictionary <string, StringValues>
{
{ "specificationId", new StringValues(SpecificationId) },
{ "policyId", new StringValues(PolicyId) },
});
request
.Query
.Returns(queryStringValues);
request
.Body
.Returns(stream);
request
.HttpContext
.Returns(context);
Specification specification = CreateSpecification();
specification
.Current
.Policies = new[]
{
new Policy
{
Id = "parent-policy-id",
Name = "policy name",
SubPolicies = new[] { new Policy {
Id = PolicyId, Name = PolicyName
} }
}
};
ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository();
specificationsRepository
.GetSpecificationById(Arg.Is(SpecificationId))
.Returns(specification);
specificationsRepository
.UpdateSpecification(Arg.Is(specification))
.Returns(HttpStatusCode.OK);
IMessengerService messengerService = CreateMessengerService();
ISearchRepository <SpecificationIndex> mockSearchRepository = CreateSearchRepository();
mockSearchRepository
.Index(Arg.Any <IEnumerable <SpecificationIndex> >())
.Returns(new List <IndexError>());
SpecificationVersion newSpecVersion = specification.Current.Clone() as SpecificationVersion;
Policy editedNewSubpolicy = newSpecVersion.Policies.First().SubPolicies.First();
editedNewSubpolicy.Name = policyEditModel.Name;
newSpecVersion.PublishStatus = PublishStatus.Updated;
IVersionRepository <SpecificationVersion> mockVersionRepository = CreateVersionRepository();
mockVersionRepository
.CreateVersion(Arg.Any <SpecificationVersion>(), Arg.Any <SpecificationVersion>())
.Returns(newSpecVersion);
SpecificationsService specificationsService = CreateService(specificationsRepository: specificationsRepository,
messengerService: messengerService, searchRepository: mockSearchRepository, specificationVersionRepository: mockVersionRepository);
// Act
IActionResult result = await specificationsService.EditPolicy(request);
// Assert
result
.Should()
.BeOfType <OkObjectResult>()
.Which
.Value
.Should()
.BeOfType <Policy>()
.Which
.Description
.Should()
.Be("new policy description");
await
messengerService
.Received(1)
.SendToTopic(Arg.Is(ServiceBusConstants.TopicNames.EditSpecification),
Arg.Is <SpecificationVersionComparisonModel>(
m => m.Id == SpecificationId
), Arg.Any <IDictionary <string, string> >(), Arg.Is(true));
await
mockSearchRepository
.Received(1)
.Index(Arg.Is <IEnumerable <SpecificationIndex> >(
m => m.First().Id == SpecificationId &&
m.First().Status == newSpecVersion.PublishStatus.ToString()
));
}
public async Task CreateVersion_GivenValidInputWithCurrentVersion_ReturnsPublishedProviderWithNewVersion()
{
//Arrange
const string providerId = "123";
const string fundingPeriodId = "456";
const string fundingStreamId = "789";
string partitionKey = $"publishedprovider_{providerId}_{fundingPeriodId}_{fundingStreamId}";
PublishedProviderVersion newCreatedVersion = new PublishedProviderVersion
{
ProviderId = providerId,
FundingPeriodId = fundingPeriodId,
FundingStreamId = fundingStreamId,
Version = 1,
Date = DateTimeOffset.Now,
PublishStatus = PublishStatus.Approved
};
PublishedProviderCreateVersionRequest publishedProviderCreateVersionRequest = new PublishedProviderCreateVersionRequest
{
PublishedProvider = new PublishedProvider
{
Current = new PublishedProviderVersion
{
ProviderId = providerId,
FundingPeriodId = fundingPeriodId,
FundingStreamId = fundingStreamId
}
},
NewVersion = new PublishedProviderVersion
{
ProviderId = providerId,
FundingPeriodId = fundingPeriodId,
FundingStreamId = fundingStreamId
}
};
IEnumerable <PublishedProviderCreateVersionRequest> versions = new[]
{
publishedProviderCreateVersionRequest
};
ILogger logger = CreateLogger();
IVersionRepository <PublishedProviderVersion> versionRepository = CreateVersionRepository();
versionRepository
.CreateVersion(Arg.Any <PublishedProviderVersion>(), Arg.Any <PublishedProviderVersion>(), Arg.Any <string>())
.Returns(newCreatedVersion);
PublishedProviderVersioningService service = CreateVersioningService(logger, versionRepository);
//Act
IEnumerable <PublishedProvider> result = await service.CreateVersions(versions);
//Assert
result
.Should()
.HaveCount(1);
result
.First()
.Current
.Should()
.BeEquivalentTo(newCreatedVersion);
}
public void EditPolicy_WhenSomethingGoesWrongDuringIndexing_ShouldThrowException()
{
// Arrange
const string errorMessage = "Encountered error code 802";
PolicyEditModel policyEditModel = new PolicyEditModel
{
SpecificationId = SpecificationId,
Name = "new policy name",
Description = "new policy description",
ParentPolicyId = "parent-policy-id"
};
string json = JsonConvert.SerializeObject(policyEditModel);
byte[] byteArray = Encoding.UTF8.GetBytes(json);
MemoryStream stream = new MemoryStream(byteArray);
HttpContext context = Substitute.For <HttpContext>();
HttpRequest request = Substitute.For <HttpRequest>();
IQueryCollection queryStringValues = new QueryCollection(new Dictionary <string, StringValues>
{
{ "specificationId", new StringValues(SpecificationId) },
{ "policyId", new StringValues(PolicyId) },
});
request
.Query
.Returns(queryStringValues);
request
.Body
.Returns(stream);
request
.HttpContext
.Returns(context);
Specification specification = CreateSpecification();
specification
.Current
.Policies = new[]
{
new Policy
{
Id = "parent-policy-id",
Name = "policy name",
SubPolicies = new[] { new Policy {
Id = PolicyId, Name = PolicyName
} }
}
};
ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository();
specificationsRepository
.GetSpecificationById(Arg.Is(SpecificationId))
.Returns(specification);
specificationsRepository
.UpdateSpecification(Arg.Is(specification))
.Returns(HttpStatusCode.OK);
IMessengerService messengerService = CreateMessengerService();
ISearchRepository <SpecificationIndex> mockSearchRepository = CreateSearchRepository();
mockSearchRepository
.Index(Arg.Any <IEnumerable <SpecificationIndex> >())
.Returns(new List <IndexError> {
new IndexError()
{
ErrorMessage = errorMessage
}
});
SpecificationVersion newSpecVersion = specification.Current.Clone() as SpecificationVersion;
Policy editedNewSubpolicy = newSpecVersion.Policies.First().SubPolicies.First();
editedNewSubpolicy.Name = policyEditModel.Name;
newSpecVersion.PublishStatus = PublishStatus.Updated;
IVersionRepository <SpecificationVersion> mockVersionRepository = CreateVersionRepository();
mockVersionRepository
.CreateVersion(Arg.Any <SpecificationVersion>(), Arg.Any <SpecificationVersion>())
.Returns(newSpecVersion);
SpecificationsService specificationsService = CreateService(specificationsRepository: specificationsRepository,
messengerService: messengerService, searchRepository: mockSearchRepository, specificationVersionRepository: mockVersionRepository);
//Act
Func <Task <IActionResult> > editPolicy = async() => await specificationsService.EditPolicy(request);
//Assert
editPolicy
.Should()
.Throw <ApplicationException>()
.Which
.Message
.Should()
.Be($"Could not index specification {specification.Current.Id} because: {errorMessage}");
}
public async Task GetPublishDates_ValidParametersPassed_ReturnsOK()
{
//Arrange
ILogger logger = CreateLogger();
string specificationId = "testSpecification";
Specification specification = new Specification
{
Current = new SpecificationVersion
{
ExternalPublicationDate = DateTimeOffset.Now.Date,
EarliestPaymentAvailableDate = DateTimeOffset.Now.Date
}
};
ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository();
IPoliciesApiClient policiesApiClient = CreatePoliciesApiClient();
IVersionRepository <SpecificationVersion> specificationVersionRepository = CreateSpecificationVersionRepository();
specificationsRepository
.GetSpecificationById(specificationId)
.Returns(specification);
SpecificationVersion clonedSpecificationVersion = null;
specificationVersionRepository.CreateVersion(Arg.Any <SpecificationVersion>(), Arg.Any <SpecificationVersion>())
.Returns(_ => (SpecificationVersion)_[0])
.AndDoes(_ => clonedSpecificationVersion = _.ArgAt <SpecificationVersion>(0));
SpecificationsService service = CreateService(
logs: logger,
specificationsRepository: specificationsRepository,
specificationVersionRepository: specificationVersionRepository,
policiesApiClient: policiesApiClient);
// Act
IActionResult result = await service.GetPublishDates(specificationId);
//Assert
result
.Should()
.BeOfType <OkObjectResult>();
var objContent = ((OkObjectResult)result);
objContent
.Should()
.NotBeNull();
SpecificationPublishDateModel publishDates = objContent.Value as SpecificationPublishDateModel;
publishDates.EarliestPaymentAvailableDate
.Should()
.Equals(specification.Current.EarliestPaymentAvailableDate);
publishDates.ExternalPublicationDate
.Should()
.Equals(specification.Current.ExternalPublicationDate);
}
public async Task SetProfileVariationPointers_UpdateSpecFails_Returns412WithErrorMessage()
{
//Arrange
ILogger logger = CreateLogger();
string specificationId = "test";
DateTimeOffset externalPublishDate = DateTimeOffset.Now.Date;
DateTimeOffset earliestPaymentAvailableDate = DateTimeOffset.Now.Date;
Specification specification = new Specification
{
Current = new SpecificationVersion
{
ExternalPublicationDate = DateTimeOffset.Now.Date,
EarliestPaymentAvailableDate = DateTimeOffset.Now.Date
}
};
IEnumerable <SpecificationProfileVariationPointerModel> specificationProfileVariationPointerModels = new SpecificationProfileVariationPointerModel[]
{
new SpecificationProfileVariationPointerModel
{
FundingLineId = "FundingLineId",
FundingStreamId = "FundingStreamId",
Occurrence = 1,
PeriodType = "PeriodType",
TypeValue = "TypeValue",
Year = 2019
}
};
ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository();
IPoliciesApiClient policiesApiClient = CreatePoliciesApiClient();
IVersionRepository <SpecificationVersion> specificationVersionRepository = CreateSpecificationVersionRepository();
specificationsRepository
.GetSpecificationById(specificationId)
.Returns(specification);
SpecificationVersion clonedSpecificationVersion = null;
specificationVersionRepository.CreateVersion(Arg.Any <SpecificationVersion>(), Arg.Any <SpecificationVersion>())
.Returns(_ => (SpecificationVersion)_[0])
.AndDoes(_ => clonedSpecificationVersion = _.ArgAt <SpecificationVersion>(0));
specificationsRepository
.UpdateSpecification(Arg.Any <Specification>())
.Returns(HttpStatusCode.BadRequest);
SpecificationsService service = CreateService(
logs: logger,
specificationsRepository: specificationsRepository,
specificationVersionRepository: specificationVersionRepository,
policiesApiClient: policiesApiClient);
// Act
IActionResult result = await service.SetProfileVariationPointers(specificationId, specificationProfileVariationPointerModels);
//Assert
result
.Should()
.BeOfType <InternalServerErrorResult>()
.Which
.Value
.Should()
.Be($"Failed to update specification for id: {specificationId} with ProfileVariationPointers {specificationProfileVariationPointerModels?.AsJson()}");
}
public async Task EditCalculationStatus_GivenNewStatusOfUpdated_UpdatesSearchReturnsOK()
{
//Arrange
EditStatusModel CalculationEditStatusModel = new EditStatusModel
{
PublishStatus = PublishStatus.Updated
};
string json = JsonConvert.SerializeObject(CalculationEditStatusModel);
byte[] byteArray = Encoding.UTF8.GetBytes(json);
MemoryStream stream = new MemoryStream(byteArray);
HttpContext context = Substitute.For <HttpContext>();
HttpRequest request = Substitute.For <HttpRequest>();
IQueryCollection queryStringValues = new QueryCollection(new Dictionary <string, StringValues>
{
{ "calculationId", new StringValues(CalculationId) },
});
request
.Query
.Returns(queryStringValues);
request
.Body
.Returns(stream);
request
.HttpContext
.Returns(context);
ILogger logger = CreateLogger();
Calculation calculation = CreateCalculation();
calculation.Current.PublishStatus = PublishStatus.Approved;
CalculationVersion calculationVersion = calculation.Current.Clone() as CalculationVersion;
calculationVersion.PublishStatus = PublishStatus.Updated;
ICalculationsRepository CalculationsRepository = CreateCalculationsRepository();
CalculationsRepository
.GetCalculationById(Arg.Is(CalculationId))
.Returns(calculation);
CalculationsRepository
.UpdateCalculation(Arg.Any <Calculation>())
.Returns(HttpStatusCode.OK);
ISearchRepository <CalculationIndex> searchRepository = CreateSearchRepository();
Models.Specs.SpecificationSummary specificationSummary = new Models.Specs.SpecificationSummary();
ISpecificationRepository specificationRepository = CreateSpecificationRepository();
specificationRepository
.GetSpecificationSummaryById(Arg.Is(calculation.SpecificationId))
.Returns(specificationSummary);
IVersionRepository <CalculationVersion> versionRepository = CreateCalculationVersionRepository();
versionRepository
.CreateVersion(Arg.Any <CalculationVersion>(), Arg.Any <CalculationVersion>())
.Returns(calculationVersion);
Build build = new Build
{
SourceFiles = new List <SourceFile> {
new SourceFile()
}
};
BuildProject buildProject = new BuildProject();
IBuildProjectsService buildProjectsService = CreateBuildProjectsService();
buildProjectsService
.GetBuildProjectForSpecificationId(Arg.Is(calculation.SpecificationId))
.Returns(buildProject);
ISourceCodeService sourceCodeService = CreateSourceCodeService();
sourceCodeService
.Compile(Arg.Any <BuildProject>(), Arg.Any <IEnumerable <Models.Calcs.Calculation> >(), Arg.Any <CompilerOptions>())
.Returns(build);
CalculationService service = CreateCalculationService(
logger: logger, calculationsRepository: CalculationsRepository, searchRepository: searchRepository,
specificationRepository: specificationRepository, calculationVersionRepository: versionRepository,
sourceCodeService: sourceCodeService, buildProjectsService: buildProjectsService);
//Act
IActionResult result = await service.UpdateCalculationStatus(request);
//Arrange
result
.Should()
.BeOfType <OkObjectResult>()
.Which
.Value
.Should()
.BeOfType <PublishStatusResultModel>()
.Which
.PublishStatus
.Should()
.Be(PublishStatus.Updated);
calculation
.Current
.PublishStatus
.Should()
.Be(PublishStatus.Updated);
await
searchRepository
.Received(1)
.Index(Arg.Is <IEnumerable <CalculationIndex> >(m => m.First().Status == "Updated"));
}
public void AssignDataDefinitionRelationship_GivenFailedToUpdateSearch_ThrowsFailedToIndexSearchException()
{
//Arrange
dynamic anyObject = new { specificationId = SpecificationId, relationshipId = RelationshipId };
string json = JsonConvert.SerializeObject(anyObject);
Message message = new Message(Encoding.UTF8.GetBytes(json));
Specification specification = new Specification
{
Id = SpecificationId,
Name = SpecificationName,
Current = new SpecificationVersion()
{
FundingStreams = new List <Reference>()
{
new Reference("fs-id", "fs-name")
},
FundingPeriod = new Reference("18/19", "2018/19"),
},
};
ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository();
specificationsRepository
.GetSpecificationById(Arg.Is(SpecificationId))
.Returns(specification);
specificationsRepository
.UpdateSpecification(Arg.Is(specification))
.Returns(HttpStatusCode.OK);
IList <IndexError> errors = new List <IndexError> {
new IndexError()
};
ISearchRepository <SpecificationIndex> searchRepository = CreateSearchRepository();
searchRepository
.Index(Arg.Any <List <SpecificationIndex> >())
.Returns(errors);
SpecificationVersion newSpecVersion = specification.Current.Clone() as SpecificationVersion;
IVersionRepository <SpecificationVersion> versionRepository = CreateVersionRepository();
versionRepository
.CreateVersion(Arg.Any <SpecificationVersion>(), Arg.Any <SpecificationVersion>())
.Returns(newSpecVersion);
SpecificationsService service = CreateService(specificationsRepository: specificationsRepository,
searchRepository: searchRepository, specificationVersionRepository: versionRepository);
//Act
Func <Task> test = async() => await service.AssignDataDefinitionRelationship(message);
//Assert
test
.Should().ThrowExactly <FailedToIndexSearchException>();
}
public async Task AssignDataDefinitionRelationship_GivenUpdatedCosmosAndSearch_LogsSuccess()
{
//Arrange
dynamic anyObject = new { specificationId = SpecificationId, relationshipId = RelationshipId };
string json = JsonConvert.SerializeObject(anyObject);
Message message = new Message(Encoding.UTF8.GetBytes(json));
Specification specification = new Specification
{
Id = SpecificationId,
Name = SpecificationName,
Current = new SpecificationVersion()
{
FundingStreams = new List <Reference>()
{
new Reference("fs-id", "fs-name")
},
FundingPeriod = new Reference("18/19", "2018/19"),
},
};
ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository();
specificationsRepository
.GetSpecificationById(Arg.Is(SpecificationId))
.Returns(specification);
specificationsRepository
.UpdateSpecification(Arg.Is(specification))
.Returns(HttpStatusCode.OK);
IList <IndexError> errors = new List <IndexError>();
ISearchRepository <SpecificationIndex> searchRepository = CreateSearchRepository();
searchRepository
.Index(Arg.Any <List <SpecificationIndex> >())
.Returns(errors);
ILogger logger = CreateLogger();
SpecificationVersion newSpecVersion = specification.Current.Clone() as SpecificationVersion;
IVersionRepository <SpecificationVersion> versionRepository = CreateVersionRepository();
versionRepository
.CreateVersion(Arg.Any <SpecificationVersion>(), Arg.Any <SpecificationVersion>())
.Returns(newSpecVersion);
SpecificationsService service = CreateService(specificationsRepository: specificationsRepository,
searchRepository: searchRepository, logs: logger, specificationVersionRepository: versionRepository);
//Act
await service.AssignDataDefinitionRelationship(message);
//Assert
logger
.Received(1)
.Information($"Successfully assigned relationship id: {RelationshipId} to specification with id: {SpecificationId}");
await
searchRepository
.Received(1)
.Index(Arg.Is <IList <SpecificationIndex> >(
m => m.First().Id == SpecificationId &&
m.First().Name == SpecificationName &&
m.First().FundingStreamIds.First() == "fs-id" &&
m.First().FundingStreamNames.First() == "fs-name" &&
m.First().FundingPeriodId == "18/19" &&
m.First().FundingPeriodName == "2018/19" &&
m.First().LastUpdatedDate.Value.Date == DateTimeOffset.Now.Date));
}
private void GivenNewVersionCreated()
{
_publishedFundingVersionRepository.CreateVersion(Arg.Is(_publishedFundingVersion), Arg.Is(_publishedFunding.Current), Arg.Is(_publishedFunding.Current.PartitionKey))
.Returns(_publishedFundingVersion);
}
public async Task EditSpecificationStatus_GivenNewStatusOfUpdated_UpdatesSearchReturnsOK()
{
//Arrange
EditStatusModel specificationEditStatusModel = new EditStatusModel
{
PublishStatus = PublishStatus.Updated
};
ILogger logger = CreateLogger();
Specification specification = CreateSpecification();
SpecificationVersion specificationVersion = specification.Current;
specificationVersion.PublishStatus = PublishStatus.Approved;
ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository();
specificationsRepository
.GetSpecificationById(Arg.Is(SpecificationId))
.Returns(specification);
specificationsRepository
.UpdateSpecification(Arg.Any <Specification>())
.Returns(HttpStatusCode.OK);
ISearchRepository <SpecificationIndex> searchRepository = CreateSearchRepository();
SpecificationVersion newSpecVersion = specificationVersion.Clone() as SpecificationVersion;
newSpecVersion.PublishStatus = PublishStatus.Updated;
IVersionRepository <SpecificationVersion> versionRepository = CreateVersionRepository();
versionRepository
.CreateVersion(Arg.Any <SpecificationVersion>(), Arg.Any <SpecificationVersion>())
.Returns(newSpecVersion);
SpecificationsService service = CreateService(
logs: logger, specificationsRepository: specificationsRepository, searchRepository: searchRepository, specificationVersionRepository: versionRepository);
//Act
IActionResult result = await service.EditSpecificationStatus(SpecificationId, specificationEditStatusModel, null);
//Arrange
result
.Should()
.BeOfType <OkObjectResult>()
.Which
.Value
.Should()
.BeOfType <PublishStatusResultModel>()
.Which
.PublishStatus
.Should()
.Be(PublishStatus.Updated);
specification
.Current
.PublishStatus
.Should()
.Be(PublishStatus.Updated);
await _specificationIndexer
.Received(1)
.Index(Arg.Is <Specification>(_ => _.Current.PublishStatus == PublishStatus.Updated));
// await
// searchRepository
// .Received(1)
// .Index(Arg.Is<IEnumerable<SpecificationIndex>>(m => m.First().Status == "Updated"));
await
versionRepository
.Received(1)
.SaveVersion(Arg.Is(newSpecVersion));
}
