public async Task CreateVersion_GivenValidInputWithCurrentVersion_EnsuresCallsCreateVersionWithCorrectParameters()
{
//Arrange
const string providerId = "123";
const string fundingPeriodId = "456";
const string fundingStreamId = "789";
string partitionKey = $"publishedprovider-{providerId}-{fundingPeriodId}-{fundingStreamId}";
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();
PublishedProviderVersioningService service = CreateVersioningService(logger, versionRepository);
//Act
IEnumerable <PublishedProvider> result = await service.CreateVersions(versions);
//Assert
await
versionRepository
.Received(1)
.CreateVersion(
Arg.Is(publishedProviderCreateVersionRequest.NewVersion),
Arg.Is <PublishedProviderVersion>(m =>
m.ProviderId == providerId &&
m.FundingPeriodId == fundingPeriodId &&
m.FundingStreamId == fundingStreamId),
Arg.Is(partitionKey));
}
public async Task UpdatePermissionForUser_WhenPermissionsAreSetOnAFundingStreamAndNoneHaveBeenSetBefore_ThenPermissionsSaved()
{
// Arrange
IUserRepository userRepository = CreateUserRepository();
User user = new User()
{
UserId = UserId
};
userRepository
.GetUserById(Arg.Is(UserId))
.Returns(user);
FundingStreamPermission existingPermission = null;
userRepository
.GetFundingStreamPermission(Arg.Is(UserId), Arg.Is(FundingStreamId))
.Returns(existingPermission);
userRepository
.UpdateFundingStreamPermission(Arg.Any <FundingStreamPermission>())
.Returns(HttpStatusCode.Created);
ICacheProvider cacheProvider = CreateCacheProvider();
FundingStreamPermissionUpdateModel updateModel = new FundingStreamPermissionUpdateModel()
{
CanApproveFunding = true,
CanChooseFunding = false,
CanCreateSpecification = false,
CanEditCalculations = false,
CanEditSpecification = false,
CanMapDatasets = false,
CanReleaseFunding = false,
CanCreateTemplates = true,
CanEditTemplates = true,
CanDeleteTemplates = true,
CanApproveTemplates = true,
CanCreateProfilePattern = true,
CanEditProfilePattern = true,
CanDeleteProfilePattern = true,
CanAssignProfilePattern = false,
CanApplyCustomProfilePattern = false,
CanApproveCalculations = true,
CanApproveAnyCalculations = false,
CanApproveAllCalculations = false
};
IVersionRepository <FundingStreamPermissionVersion> versionRepository = CreateFundingStreamPermissionRepository();
versionRepository
.GetNextVersionNumber(Arg.Any <FundingStreamPermissionVersion>(), 0, Arg.Is(UserId))
.Returns(1);
FundingStreamPermissionService service = CreateService(
userRepository,
cacheProvider: cacheProvider,
fundingStreamPermissionVersionRepository: versionRepository);
// Act
IActionResult result = await service.UpdatePermissionForUser(UserId, FundingStreamId, updateModel, null);
// Assert
result
.Should()
.BeOfType <OkObjectResult>()
.Which
.Value
.Should()
.BeEquivalentTo <FundingStreamPermissionCurrent>(new FundingStreamPermissionCurrent()
{
UserId = UserId,
FundingStreamId = FundingStreamId,
CanApproveFunding = true,
CanChooseFunding = false,
CanCreateSpecification = false,
CanEditCalculations = false,
CanEditSpecification = false,
CanMapDatasets = false,
CanReleaseFunding = false,
CanCreateTemplates = true,
CanEditTemplates = true,
CanDeleteTemplates = true,
CanApproveTemplates = true,
CanCreateProfilePattern = true,
CanEditProfilePattern = true,
CanDeleteProfilePattern = true,
CanAssignProfilePattern = false,
CanApplyCustomProfilePattern = false,
CanApproveCalculations = true,
CanApproveAnyCalculations = false,
CanApproveAllCalculations = false,
});
await userRepository
.Received(1)
.UpdateFundingStreamPermission(Arg.Is <FundingStreamPermission>(p =>
p.FundingStreamId == FundingStreamId &&
p.UserId == UserId &&
p.CanApproveFunding &&
!p.CanChooseFunding &&
!p.CanCreateSpecification &&
!p.CanEditCalculations &&
!p.CanEditSpecification &&
!p.CanMapDatasets &&
!p.CanReleaseFunding &&
p.CanCreateTemplates &&
p.CanEditTemplates &&
p.CanDeleteTemplates &&
p.CanApproveTemplates &&
p.CanCreateProfilePattern &&
p.CanEditProfilePattern &&
p.CanDeleteProfilePattern &&
!p.CanAssignProfilePattern &&
!p.CanApplyCustomProfilePattern &&
p.CanApproveCalculations &&
!p.CanApproveAnyCalculations &&
!p.CanApproveAllCalculations
));
await cacheProvider
.Received(1)
.DeleteHashSet(Arg.Is($"{CacheKeys.EffectivePermissions}:{UserId}"));
await versionRepository
.Received(1)
.GetNextVersionNumber(Arg.Is <FundingStreamPermissionVersion>(v => v.EntityId == $"{UserId}_{FundingStreamId}"), partitionKeyId: Arg.Is(UserId));
await versionRepository
.Received(1)
.SaveVersion(Arg.Is <FundingStreamPermissionVersion>(v =>
v.EntityId == $"{UserId}_{FundingStreamId}" &&
v.Version == 1
), Arg.Is(UserId));
}
public async Task EditPolicy_WhenPolicyWasASubPolicyButNowTopLevelPolicy_SavesChanges()
{
// Arrange
PolicyEditModel policyEditModel = new PolicyEditModel
{
SpecificationId = SpecificationId,
Name = "new policy name",
Description = "new policy description",
ParentPolicyId = null
};
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();
SpecificationVersion newSpecVersion = specification.Current.Clone() as SpecificationVersion;
newSpecVersion.Policies = newSpecVersion.Policies.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();
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 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 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 async Task CreateAdditionalCalculation_GivenCalcSaves_ReturnsOKObjectResult()
{
//Arrange
string cacheKey = $"{CacheKeys.CalculationsMetadataForSpecification}{SpecificationId}";
CalculationCreateModel model = CreateCalculationCreateModel();
Reference author = CreateAuthor();
ICalculationsRepository calculationsRepository = CreateCalculationsRepository();
calculationsRepository
.CreateDraftCalculation(Arg.Any <Calculation>())
.Returns(HttpStatusCode.OK);
IVersionRepository <CalculationVersion> versionRepository = CreateCalculationVersionRepository();
ISearchRepository <CalculationIndex> searchRepository = CreateSearchRepository();
IJobManagement jobManagement = CreateJobManagement();
jobManagement
.QueueJob(Arg.Any <JobCreateModel>())
.Returns(new Job {
Id = "job-id-1"
});
ISpecificationsApiClient specificationsApiClient = CreateSpecificationsApiClient();
specificationsApiClient
.GetSpecificationSummaryById(Arg.Is(SpecificationId))
.Returns(new ApiResponse <SpecificationSummary>(
HttpStatusCode.OK,
new SpecificationSummary {
Id = SpecificationId,
FundingPeriod = new FundingPeriod {
Id = FundingPeriodId
}
}
));
ILogger logger = CreateLogger();
ICacheProvider cacheProvider = CreateCacheProvider();
ICodeContextCache codeContextCache = Substitute.For <ICodeContextCache>();
IResultsApiClient resultsApiClient = CreateResultsApiClient();
CalculationService calculationService = CreateCalculationService(
calculationsRepository: calculationsRepository,
calculationVersionRepository: versionRepository,
searchRepository: searchRepository,
jobManagement: jobManagement,
logger: logger,
cacheProvider: cacheProvider,
specificationsApiClient: specificationsApiClient,
codeContextCache: codeContextCache,
resultsApiClient: resultsApiClient);
IEnumerable <CalculationIndex> indexedCalculations = null;
await
searchRepository
.Index(Arg.Do <IEnumerable <CalculationIndex> >(m =>
indexedCalculations = m
));
CalculationVersion savedCalculationVersion = null;
await
versionRepository
.SaveVersion(Arg.Do <CalculationVersion>(m => savedCalculationVersion = m));
//Act
IActionResult result = await calculationService.CreateAdditionalCalculation(SpecificationId, model, author, CorrelationId);
//Assert
result
.Should()
.BeAssignableTo <OkObjectResult>();
Calculation calculation = (result as OkObjectResult).Value as Calculation;
await
jobManagement
.Received(1)
.QueueJob(Arg.Is <JobCreateModel>(
m =>
m.InvokerUserDisplayName == Username &&
m.InvokerUserId == UserId &&
m.JobDefinitionId == JobConstants.DefinitionNames.CreateInstructAllocationJob &&
m.Properties["specification-id"] == SpecificationId
));
logger
.Received(1)
.Information(Arg.Is($"New job of type '{JobConstants.DefinitionNames.CreateInstructAllocationJob}' created with id: 'job-id-1'"));
await
versionRepository
.Received(1)
.SaveVersion(Arg.Is <CalculationVersion>(m =>
m.PublishStatus == Models.Versioning.PublishStatus.Draft &&
m.Author.Id == UserId &&
m.Author.Name == Username &&
m.Date.Date == DateTimeOffset.Now.Date &&
m.Version == 1 &&
m.SourceCode == model.SourceCode &&
m.Description == model.Description &&
m.ValueType == model.ValueType &&
m.CalculationType == CalculationType.Additional &&
m.WasTemplateCalculation == false &&
m.Namespace == CalculationNamespace.Additional &&
m.Name == model.Name &&
m.SourceCodeName == new VisualBasicTypeIdentifierGenerator().GenerateIdentifier(model.Name) &&
m.DataType == CalculationDataType.Decimal
));
await searchRepository
.Received(1)
.Index(Arg.Any <IEnumerable <CalculationIndex> >());
indexedCalculations
.Should()
.BeEquivalentTo(new List <CalculationIndex>()
{
new CalculationIndex()
{
CalculationType = "Additional",
Description = "test description",
FundingStreamId = "fs-1",
FundingStreamName = model.FundingStreamName,
Id = model.Id,
Name = model.Name,
Namespace = "Additional",
SpecificationId = "spec-id-1",
SpecificationName = "spec-id-1_specificationName",
Status = "Draft",
ValueType = "Currency",
WasTemplateCalculation = false,
LastUpdatedDate = savedCalculationVersion.Date,
}
});
//!string.IsNullOrWhiteSpace(m.First().Id) &&
//m.First().Name == model.Name &&
//m.First().SpecificationId == SpecificationId &&
//m.First().SpecificationName == model.SpecificationName &&
//m.First().ValueType == model.ValueType.ToString() &&
//m.First().CalculationType == CalculationType.Additional.ToString() &&
//m.First().Namespace == CalculationNamespace.Additional.ToString() &&
//m.First().FundingStreamId == model.FundingStreamId &&
//m.First().FundingStreamName == model.FundingStreamName &&
//m.First().WasTemplateCalculation == false &&
//m.First().Description == model.Description &&
//m.First().Status == calculation.Current.PublishStatus.ToString()
await
cacheProvider
.Received(1)
.RemoveAsync <List <CalculationMetadata> >(Arg.Is(cacheKey));
await codeContextCache
.Received(1)
.QueueCodeContextCacheUpdate(SpecificationId);
}
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 UpdatePermissionForUser_WhenPermissionsAreSetOnAFundingStreamAndNoneHaveBeenSetBefore_ThenPermissionsSaved()
{
// Arrange
IUserRepository userRepository = CreateUserRepository();
User user = new User()
{
UserId = UserId
};
userRepository
.GetUserById(Arg.Is(UserId))
.Returns(user);
FundingStreamPermission existingPermission = null;
userRepository
.GetFundingStreamPermission(Arg.Is(UserId), Arg.Is(FundingStreamId))
.Returns(existingPermission);
userRepository
.UpdateFundingStreamPermission(Arg.Any <FundingStreamPermission>())
.Returns(HttpStatusCode.Created);
ICacheProvider cacheProvider = CreateCacheProvider();
FundingStreamPermissionUpdateModel updateModel = new FundingStreamPermissionUpdateModel()
{
CanApproveFunding = true,
CanChooseFunding = false,
CanCreateSpecification = false,
CanEditCalculations = false,
CanEditSpecification = false,
CanMapDatasets = false,
CanPublishFunding = false,
};
string json = JsonConvert.SerializeObject(updateModel);
byte[] byteArray = Encoding.UTF8.GetBytes(json);
MemoryStream stream = new MemoryStream(byteArray);
HttpRequest request = Substitute.For <HttpRequest>();
request
.Body
.Returns(stream);
IVersionRepository <FundingStreamPermissionVersion> versionRepository = CreateFundingStreamPermissionRepository();
versionRepository
.GetNextVersionNumber(Arg.Any <FundingStreamPermissionVersion>(), 0, Arg.Is(UserId))
.Returns(1);
FundingStreamPermissionService service = CreateService(
userRepository,
cacheProvider: cacheProvider,
fundingStreamPermissionVersionRepository: versionRepository);
// Act
IActionResult result = await service.UpdatePermissionForUser(UserId, FundingStreamId, request);
// Assert
result
.Should()
.BeOfType <OkObjectResult>()
.Which
.Value
.Should()
.BeEquivalentTo <FundingStreamPermissionCurrent>(new FundingStreamPermissionCurrent()
{
UserId = UserId,
FundingStreamId = FundingStreamId,
CanApproveFunding = true,
CanChooseFunding = false,
CanCreateSpecification = false,
CanEditCalculations = false,
CanEditSpecification = false,
CanMapDatasets = false,
CanPublishFunding = false,
});
await userRepository
.Received(1)
.UpdateFundingStreamPermission(Arg.Is <FundingStreamPermission>(p =>
p.FundingStreamId == FundingStreamId &&
p.UserId == UserId &&
p.CanApproveFunding &&
!p.CanChooseFunding &&
!p.CanCreateSpecification &&
!p.CanEditCalculations &&
!p.CanEditSpecification &&
!p.CanMapDatasets &&
!p.CanPublishFunding
));
await cacheProvider
.Received(1)
.DeleteHashSet(Arg.Is($"{CacheKeys.EffectivePermissions}:{UserId}"));
await versionRepository
.Received(1)
.GetNextVersionNumber(Arg.Is <FundingStreamPermissionVersion>(v => v.EntityId == $"{UserId}_{FundingStreamId}"), partitionKeyId: Arg.Is(UserId));
await versionRepository
.Received(1)
.SaveVersion(Arg.Is <FundingStreamPermissionVersion>(v =>
v.EntityId == $"{UserId}_{FundingStreamId}" &&
v.Version == 1
), Arg.Is(UserId));
}
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));
}
public async Task SpecificationsService_CreateSpecification_WhenValidInputProvided_ThenSpecificationIsCreated()
{
// Arrange
const string fundingStreamId = "fs1";
const string fundingPeriodId = "fp1";
ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository();
ISearchRepository <SpecificationIndex> searchRepository = CreateSearchRepository();
IMapper mapper = CreateImplementedMapper();
IVersionRepository <SpecificationVersion> versionRepository = CreateVersionRepository();
SpecificationsService specificationsService = CreateService(
specificationsRepository: specificationsRepository,
searchRepository: searchRepository,
mapper: mapper,
specificationVersionRepository: versionRepository);
SpecificationCreateModel specificationCreateModel = new SpecificationCreateModel()
{
Name = "Specification Name",
Description = "Specification Description",
FundingPeriodId = "fp1",
FundingStreamIds = new List <string>()
{
fundingStreamId
},
};
string json = JsonConvert.SerializeObject(specificationCreateModel);
byte[] byteArray = Encoding.UTF8.GetBytes(json);
MemoryStream stream = new MemoryStream(byteArray);
ClaimsPrincipal principle = new ClaimsPrincipal(new[]
{
new ClaimsIdentity(new [] { new Claim(ClaimTypes.Sid, UserId), new Claim(ClaimTypes.Name, Username) })
});
HttpContext context = Substitute.For <HttpContext>();
context
.User
.Returns(principle);
HttpRequest request = Substitute.For <HttpRequest>();
request
.Body
.Returns(stream);
request
.HttpContext
.Returns(context);
specificationsRepository
.GetSpecificationByQuery(Arg.Any <Expression <Func <Specification, bool> > >())
.Returns((Specification)null);
Period fundingPeriod = new Period()
{
Id = fundingPeriodId,
Name = "Funding Period 1"
};
specificationsRepository
.GetPeriodById(Arg.Is(fundingPeriodId))
.Returns(fundingPeriod);
FundingStream fundingStream = new FundingStream()
{
Id = fundingStreamId,
Name = "Funding Stream 1",
AllocationLines = new List <AllocationLine>(),
};
specificationsRepository
.GetFundingStreamById(Arg.Is(fundingStreamId))
.Returns(fundingStream);
DateTime createdDate = new DateTime(2018, 1, 2, 5, 6, 2);
SpecificationVersion specificationVersion = new SpecificationVersion()
{
Description = "Specification Description",
FundingPeriod = new Reference("fp1", "Funding Period 1"),
Date = createdDate,
PublishStatus = Models.Versioning.PublishStatus.Draft,
FundingStreams = new List <Reference>()
{
new Reference(FundingStreamId, "Funding Stream 1")
},
Name = "Specification Name",
Version = 1,
SpecificationId = SpecificationId
};
versionRepository
.CreateVersion(Arg.Any <SpecificationVersion>())
.Returns(specificationVersion);
DocumentEntity <Specification> createdSpecification = new DocumentEntity <Specification>()
{
Content = new Specification()
{
Name = "Specification Name",
Id = "createdSpec",
Current = specificationVersion
},
};
specificationsRepository
.CreateSpecification(Arg.Is <Specification>(
s => s.Name == specificationCreateModel.Name &&
s.Current.Description == specificationCreateModel.Description &&
s.Current.FundingPeriod.Id == fundingPeriodId))
.Returns(createdSpecification);
// Act
IActionResult result = await specificationsService.CreateSpecification(request);
// Assert
result
.Should()
.BeOfType <OkObjectResult>()
.Which
.Value
.Should()
.BeOfType <SpecificationCurrentVersion>()
.And
.NotBeNull();
await specificationsRepository
.Received(1)
.CreateSpecification(Arg.Is <Specification>(
s => s.Name == specificationCreateModel.Name &&
s.Current.Description == specificationCreateModel.Description &&
s.Current.FundingPeriod.Id == fundingPeriodId));
await searchRepository
.Received(1)
.Index(Arg.Is <List <SpecificationIndex> >(c =>
c.Count() == 1 &&
!string.IsNullOrWhiteSpace(c.First().Id) &&
c.First().Name == specificationCreateModel.Name
));
await versionRepository
.Received(1)
.SaveVersion(Arg.Is <SpecificationVersion>(
m => !string.IsNullOrWhiteSpace(m.EntityId) &&
m.PublishStatus == Models.Versioning.PublishStatus.Draft &&
m.Description == "Specification Description" &&
m.FundingPeriod.Id == "fp1" &&
m.FundingPeriod.Name == "Funding Period 1" &&
m.FundingStreams.Any() &&
m.Name == "Specification Name" &&
m.Version == 1
));
}
public async Task EditSpecificationStatus_GivenNewStatusOfUpdated_UpdatesSearchReturnsOK()
{
//Arrange
EditStatusModel specificationEditStatusModel = new EditStatusModel
{
PublishStatus = PublishStatus.Updated
};
string json = JsonConvert.SerializeObject(specificationEditStatusModel);
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();
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(request);
//Arrange
result
.Should()
.BeOfType <OkObjectResult>()
.Which
.Value
.Should()
.BeOfType <PublishStatusResultModel>()
.Which
.PublishStatus
.Should()
.Be(PublishStatus.Updated);
specification
.Current
.PublishStatus
.Should()
.Be(PublishStatus.Updated);
await
searchRepository
.Received(1)
.Index(Arg.Is <IEnumerable <SpecificationIndex> >(m => m.First().Status == "Updated"));
await
versionRepository
.Received(1)
.SaveVersion(Arg.Is(newSpecVersion));
}
