public async Task SelectSpecificationForFunding_GivenSpecificationButUpdatingCosmosReturnsBadRequest_ReturnsInternalServerError()
{
//Arrange
Specification specification = CreateSpecification();
ILogger logger = CreateLogger();
ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository();
specificationsRepository
.GetSpecificationById(Arg.Is(SpecificationId))
.Returns(specification);
specificationsRepository
.UpdateSpecification(Arg.Is(specification))
.Returns(HttpStatusCode.BadRequest);
SpecificationsService service = CreateService(logs: logger, specificationsRepository: specificationsRepository);
//Act
IActionResult result = await service.SelectSpecificationForFunding(SpecificationId);
//Assert
result
.Should()
.BeOfType <InternalServerErrorResult>()
.Which
.Value
.Should()
.Be($"Failed to set IsSelectedForFunding on specification for id: {SpecificationId} with status code: BadRequest");
logger
.Received(1)
.Error($"Failed to set IsSelectedForFunding on specification for id: {SpecificationId} with status code: BadRequest");
}
public async Task SelectSpecificationForFunding_GivenValidSpecification_ReturnsNoContentResult()
{
// Arrange
IQueryCollection queryStringValues = new QueryCollection(new Dictionary <string, StringValues>
{
{ "specificationId", new StringValues(SpecificationId) }
});
HttpRequest request = Substitute.For <HttpRequest>();
request
.Query
.Returns(queryStringValues);
Specification specification = CreateSpecification();
ILogger logger = CreateLogger();
ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository();
specificationsRepository
.GetSpecificationById(Arg.Is(SpecificationId))
.Returns(specification);
specificationsRepository
.UpdateSpecification(Arg.Is(specification))
.Returns(HttpStatusCode.OK);
IJobsApiClient jobsApiClient = CreateJobsApiClient();
ICacheProvider cacheProvider = CreateCacheProvider();
SpecificationsService service = CreateService(
logs: logger,
specificationsRepository: specificationsRepository,
jobsApiClient: jobsApiClient,
cacheProvider: cacheProvider);
// Act
IActionResult result = await service.SelectSpecificationForFunding(request);
// Assert
result
.Should()
.BeOfType <NoContentResult>();
await jobsApiClient
.Received(1)
.CreateJob(Arg.Is <JobCreateModel>(j => j.JobDefinitionId == JobConstants.DefinitionNames.PublishProviderResultsJob && j.SpecificationId == SpecificationId && j.Trigger.Message == $"Selecting specification for funding"));
await cacheProvider
.Received(1)
.RemoveAsync <SpecificationSummary>($"{CacheKeys.SpecificationSummaryById}{specification.Id}");
await cacheProvider
.Received(1)
.RemoveAsync <SpecificationCurrentVersion>($"{CacheKeys.SpecificationCurrentVersionById}{specification.Id}");
}
public async Task SelectSpecificationForFunding_GivenSpecificationButUpdatingSearchFails_ReturnsInternalServerError()
{
// Arrange
Specification specification = CreateSpecification();
ILogger logger = CreateLogger();
ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository();
specificationsRepository
.GetSpecificationById(Arg.Is(SpecificationId))
.Returns(specification);
specificationsRepository
.UpdateSpecification(Arg.Is(specification))
.Returns(HttpStatusCode.OK);
// IEnumerable<IndexError> errors = new[]
// {
// new IndexError{ ErrorMessage = "failed" }
// };
// ISearchRepository<SpecificationIndex> searchRepository = CreateSearchRepository();
// searchRepository
// .Index(Arg.Any<IEnumerable<SpecificationIndex>>())
// .Returns(errors);
_specificationIndexer
.When(_ => _.Index(Arg.Is <Specification>(sp => sp.IsSelectedForFunding)))
.Throw(new Exception());
ICacheProvider cacheProvider = CreateCacheProvider();
SpecificationsService service = CreateService(
logs: logger,
specificationsRepository: specificationsRepository,
cacheProvider: cacheProvider);
// Act
IActionResult result = await service.SelectSpecificationForFunding(SpecificationId);
// Assert
result
.Should()
.BeOfType <InternalServerErrorResult>();
// logger
// .Received(1)
// .Error(Arg.Is($"Failed to index search for specification {SpecificationId} with the following errors: failed"));
//
// logger
// .Received(1)
// .Error(Arg.Any<Exception>(), Arg. ($"Failed to index search for specification {SpecificationId} with the following errors: failed"));
await cacheProvider
.Received(1)
.RemoveAsync <SpecificationSummary>($"{CacheKeys.SpecificationSummaryById}{specification.Id}");
}
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 EditSpecificationStatus_GivenSpecificationISApprovedButNewStatusIsDraft_ThenBadRequestReturned()
{
//Arrange
EditStatusModel specificationEditStatusModel = new EditStatusModel
{
PublishStatus = PublishStatus.Draft
};
ILogger logger = CreateLogger();
Specification specification = CreateSpecification();
specification.Current.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();
SpecificationsService service = CreateService(
logs: logger, specificationsRepository: specificationsRepository, searchRepository: searchRepository);
// Act
IActionResult result = await service.EditSpecificationStatus(SpecificationId, specificationEditStatusModel, null);
// Arrange
result
.Should()
.BeOfType <BadRequestObjectResult>()
.Which
.Value
.Should()
.Be("Publish status can't be changed to Draft from Updated or Approved");
specification
.Current
.PublishStatus
.Should()
.Be(PublishStatus.Approved);
await
searchRepository
.Received(0)
.Index(Arg.Any <IEnumerable <SpecificationIndex> >());
}
public async Task UpdateCacheWithCalculationStarted_GivenSpecificationButUpdatingFails_ReturnsInternalServerError()
{
//Arrange
Specification specification = new Specification
{
Id = SpecificationId
};
IQueryCollection queryStringValues = new QueryCollection(new Dictionary <string, StringValues>
{
{ "specificationId", new StringValues(SpecificationId) }
});
HttpRequest request = Substitute.For <HttpRequest>();
request
.Query
.Returns(queryStringValues);
ILogger logger = CreateLogger();
ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository();
specificationsRepository
.GetSpecificationById(Arg.Is(SpecificationId))
.Returns(specification);
specificationsRepository
.UpdateSpecification(Arg.Is(specification))
.Returns(HttpStatusCode.BadRequest);
SpecificationsService service = CreateService(logs: logger, specificationsRepository: specificationsRepository);
//Act
IActionResult actionResult = await service.UpdateCalculationLastUpdatedDate(request);
//Assert
actionResult
.Should()
.BeOfType <InternalServerErrorResult>()
.Which
.Value
.Should()
.Be($"Failed to update calculation last updated date on specification {SpecificationId}");
logger
.Received(1)
.Error($"Failed to update calculation last updated date on specification {SpecificationId}");
}
public async Task UpdateCacheWithCalculationStarted_GivenSpecificationButUpdatingAndUpdateSucceeeds_ReturnsNoContentRemovesFromCache()
{
//Arrange
Specification specification = new Specification
{
Id = SpecificationId
};
IQueryCollection queryStringValues = new QueryCollection(new Dictionary <string, StringValues>
{
{ "specificationId", new StringValues(SpecificationId) }
});
HttpRequest request = Substitute.For <HttpRequest>();
request
.Query
.Returns(queryStringValues);
ILogger logger = CreateLogger();
ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository();
specificationsRepository
.GetSpecificationById(Arg.Is(SpecificationId))
.Returns(specification);
specificationsRepository
.UpdateSpecification(Arg.Is(specification))
.Returns(HttpStatusCode.OK);
ICacheProvider cacheProvider = CreateCacheProvider();
SpecificationsService service = CreateService(logs: logger, specificationsRepository: specificationsRepository, cacheProvider: cacheProvider);
//Act
IActionResult actionResult = await service.UpdateCalculationLastUpdatedDate(request);
//Assert
actionResult
.Should()
.BeOfType <NoContentResult>();
await
cacheProvider
.Received(1)
.RemoveAsync <SpecificationSummary>(Arg.Is($"{CacheKeys.SpecificationSummaryById}{SpecificationId}"));
}
public async Task SelectSpecificationForFunding_GivenSpecificationButUpdatingCosmosReturnsBadRequest_ReturnsInternalServerError()
{
//Arrange
IQueryCollection queryStringValues = new QueryCollection(new Dictionary <string, StringValues>
{
{ "specificationId", new StringValues(SpecificationId) }
});
HttpRequest request = Substitute.For <HttpRequest>();
request
.Query
.Returns(queryStringValues);
Specification specification = CreateSpecification();
ILogger logger = CreateLogger();
ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository();
specificationsRepository
.GetSpecificationById(Arg.Is(SpecificationId))
.Returns(specification);
specificationsRepository
.UpdateSpecification(Arg.Is(specification))
.Returns(HttpStatusCode.BadRequest);
SpecificationsService service = CreateService(logs: logger, specificationsRepository: specificationsRepository);
//Act
IActionResult result = await service.SelectSpecificationForFunding(request);
//Assert
result
.Should()
.BeOfType <InternalServerErrorResult>()
.Which
.Value
.Should()
.Be($"Failed to set IsSelectedForFunding on specification for id: {SpecificationId} with status code: BadRequest");
logger
.Received(1)
.Error($"Failed to set IsSelectedForFunding on specification for id: {SpecificationId} with status code: BadRequest");
}
public async Task UpdatePublishedRefreshedDate_WhenUpdateIsUnsuccessful_ThenInternalServerErrorReturned()
{
// Arrange
IQueryCollection queryStringValues = new QueryCollection(new Dictionary <string, StringValues>
{
{ "specificationId", new StringValues(SpecificationId) }
});
Specification specification = new Specification
{
Id = SpecificationId,
Name = "spec1"
};
UpdatePublishedRefreshedDateModel updateModel = new UpdatePublishedRefreshedDateModel
{
PublishedResultsRefreshedAt = DateTimeOffset.Now.AddHours(-1)
};
string json = JsonConvert.SerializeObject(updateModel);
byte[] byteArray = Encoding.UTF8.GetBytes(json);
MemoryStream stream = new MemoryStream(byteArray);
HttpContext context = Substitute.For <HttpContext>();
ISpecificationsRepository specsRepo = CreateSpecificationsRepository();
specsRepo.GetSpecificationById(Arg.Is(SpecificationId)).Returns(specification);
specsRepo.UpdateSpecification(Arg.Is(specification)).Returns(HttpStatusCode.InternalServerError);
SpecificationsService specsService = CreateService(specificationsRepository: specsRepo);
HttpRequest request = Substitute.For <HttpRequest>();
request.Query.Returns(queryStringValues);
request.Body.Returns(stream);
request.HttpContext.Returns(context);
// Act
IActionResult result = await specsService.UpdatePublishedRefreshedDate(request);
// Assert
result.Should().BeOfType <InternalServerErrorResult>().Which.Value.Should().Be($"Failed to set PublishedResultsRefreshedAt on specification for id: {SpecificationId} to value: {updateModel.PublishedResultsRefreshedAt.ToString()}");
}
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 void AssignDataDefinitionRelationship_GivenFailedToUpdateSpecification_ThrowsException()
{
//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()
{
Current = new Models.Specs.SpecificationVersion(),
};
ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository();
specificationsRepository
.GetSpecificationById(Arg.Is(SpecificationId))
.Returns(specification);
specificationsRepository
.UpdateSpecification(Arg.Is(specification))
.Returns(HttpStatusCode.InternalServerError);
ILogger logger = CreateLogger();
SpecificationsService service = CreateService(specificationsRepository: specificationsRepository, logs: logger);
//Act
Func <Task> test = async() => await service.Process(message);
//Assert
test
.Should().ThrowExactly <Exception>();
logger
.Received()
.Error($"Failed to update specification for id: {SpecificationId} with dataset definition relationship id {RelationshipId}");
}
public async Task EditSpecificationStatus_GivenNewStatusButUpdatingDbReturnsBadRequest_ReturnsStatusCode400()
{
//Arrange
EditStatusModel specificationEditStatusModel = new EditStatusModel
{
PublishStatus = PublishStatus.Approved
};
ILogger logger = CreateLogger();
Specification specification = CreateSpecification();
ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository();
specificationsRepository
.GetSpecificationById(Arg.Is(SpecificationId))
.Returns(specification);
specificationsRepository
.UpdateSpecification(Arg.Any <Specification>())
.Returns(HttpStatusCode.BadRequest);
SpecificationsService service = CreateService(
logs: logger, specificationsRepository: specificationsRepository);
//Act
IActionResult result = await service.EditSpecificationStatus(SpecificationId, specificationEditStatusModel, null);
//Arrange
result
.Should()
.BeAssignableTo <StatusCodeResult>()
.Which
.StatusCode
.Should()
.Be(400);
}
public async Task SelectSpecificationForFunding_GivenValidSpecification_ReturnsNoContentResult()
{
// Arrange
Specification specification = CreateSpecification();
ILogger logger = CreateLogger();
ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository();
specificationsRepository
.GetSpecificationById(Arg.Is(SpecificationId))
.Returns(specification);
specificationsRepository
.UpdateSpecification(Arg.Is(specification))
.Returns(HttpStatusCode.OK);
ICacheProvider cacheProvider = CreateCacheProvider();
SpecificationsService service = CreateService(
logs: logger,
specificationsRepository: specificationsRepository,
cacheProvider: cacheProvider);
// Act
IActionResult result = await service.SelectSpecificationForFunding(SpecificationId);
// Assert
result
.Should()
.BeOfType <NoContentResult>();
await cacheProvider
.Received(1)
.RemoveAsync <SpecificationSummary>($"{CacheKeys.SpecificationSummaryById}{specification.Id}");
}
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 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 EditPolicy_WhenValidModelButUpdateCosmosReturnsBadRequest_ReturnsBadRequest()
{
// Arrange
PolicyEditModel policyEditModel = new PolicyEditModel
{
SpecificationId = SpecificationId,
Name = "new policy name"
};
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 = PolicyId, Name = PolicyName
} };
ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository();
specificationsRepository
.GetSpecificationById(Arg.Is(SpecificationId))
.Returns(specification);
specificationsRepository
.UpdateSpecification(Arg.Is(specification))
.Returns(HttpStatusCode.BadRequest);
SpecificationsService specificationsService = CreateService(specificationsRepository: specificationsRepository);
// Act
IActionResult result = await specificationsService.EditPolicy(request);
// Assert
result
.Should()
.BeOfType <StatusCodeResult>()
.Which
.StatusCode
.Should()
.Be(400);
}
public async Task SelectSpecificationForFunding_GivenSpecificationButUpdatingSearchFails_ReturnsInternalServerError()
{
// Arrange
IQueryCollection queryStringValues = new QueryCollection(new Dictionary <string, StringValues>
{
{ "specificationId", new StringValues(SpecificationId) }
});
HttpRequest request = Substitute.For <HttpRequest>();
request
.Query
.Returns(queryStringValues);
Specification specification = CreateSpecification();
ILogger logger = CreateLogger();
ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository();
specificationsRepository
.GetSpecificationById(Arg.Is(SpecificationId))
.Returns(specification);
specificationsRepository
.UpdateSpecification(Arg.Is(specification))
.Returns(HttpStatusCode.OK);
IEnumerable <IndexError> errors = new[]
{
new IndexError {
ErrorMessage = "failed"
}
};
ISearchRepository <SpecificationIndex> searchRepository = CreateSearchRepository();
searchRepository
.Index(Arg.Any <IEnumerable <SpecificationIndex> >())
.Returns(errors);
ICacheProvider cacheProvider = CreateCacheProvider();
SpecificationsService service = CreateService(
logs: logger,
specificationsRepository: specificationsRepository,
searchRepository: searchRepository,
cacheProvider: cacheProvider);
// Act
IActionResult result = await service.SelectSpecificationForFunding(request);
// Assert
result
.Should()
.BeOfType <InternalServerErrorResult>()
.Which
.Value
.Should()
.Be($"Failed to index search for specification {SpecificationId} with the following errors: failed");
logger
.Received(1)
.Error(Arg.Is($"Failed to index search for specification {SpecificationId} with the following errors: failed"));
logger
.Received(1)
.Error(Arg.Any <Exception>(), Arg.Is($"Failed to index search for specification {SpecificationId} with the following errors: failed"));
await cacheProvider
.Received(1)
.RemoveAsync <SpecificationSummary>($"{CacheKeys.SpecificationSummaryById}{specification.Id}");
await cacheProvider
.Received(1)
.RemoveAsync <SpecificationCurrentVersion>($"{CacheKeys.SpecificationCurrentVersionById}{specification.Id}");
}
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));
}
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 EditSpecification_GivenFailsToUpdateCosomosWithBadRequest_ReturnsBadRequest()
{
//Arrange
SpecificationEditModel specificationEditModel = new SpecificationEditModel
{
FundingPeriodId = "fp10"
};
Period fundingPeriod = new Period
{
Id = "fp10",
Name = "fp 10"
};
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.BadRequest);
SpecificationsService service = CreateService(logs: logger, specificationsRepository: specificationsRepository);
//Act
IActionResult result = await service.EditSpecification(request);
//Arrange
result
.Should()
.BeOfType <StatusCodeResult>()
.Which
.StatusCode
.Should()
.Be(400);
}
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 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 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 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 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 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
} });
}
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 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>();
}
