public async Task EditSpecificationStatus_GivenSpecificationWasNotFound_ReturnsNotFoundResult()
{
//Arrange
EditStatusModel specificationEditStatusModel = new EditStatusModel
{
PublishStatus = PublishStatus.Approved
};
ILogger logger = CreateLogger();
ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository();
specificationsRepository
.GetSpecificationById(Arg.Is(SpecificationId))
.Returns((Specification)null);
SpecificationsService service = CreateService(logs: logger, specificationsRepository: specificationsRepository);
//Act
IActionResult result = await service.EditSpecificationStatus(SpecificationId, specificationEditStatusModel, null);
//Arrange
result
.Should()
.BeOfType <NotFoundObjectResult>()
.Which
.Value
.Should()
.Be("Specification not found");
logger
.Received(1)
.Warning(Arg.Is($"Failed to find specification for id: {SpecificationId}"));
}
public async Task GetSpecificationById_GivenSpecificationWasFound_ReturnsSuccess()
{
//Arrange
Specification specification = new Specification();
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);
SpecificationsService service = CreateService(specificationsRepository: specificationsRepository, logs: logger);
//Act
IActionResult result = await service.GetSpecificationById(request);
//Assert
result
.Should()
.BeOfType <OkObjectResult>();
}
public async Task GetSpecificationById_GivenSpecificationWasNotFound_ReturnsNotFound()
{
//Arrange
ILogger logger = CreateLogger();
ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository();
specificationsRepository
.GetSpecificationById(Arg.Is(SpecificationId))
.Returns((Specification)null);
SpecificationsService service = CreateService(specificationsRepository: specificationsRepository, logs: logger);
//Act
IActionResult result = await service.GetSpecificationById(SpecificationId);
//Assert
result
.Should()
.BeOfType <NotFoundResult>();
logger
.Received(1)
.Warning(Arg.Is($"A specification for id {SpecificationId} could not found"));
}
public void AssignDataDefinitionRelationship_GivenValidMessageButUnableToFindSpecification_ThrowsInvalidModelException()
{
//Arrange
dynamic anyObject = new { specificationId = SpecificationId, relationshipId = RelationshipId };
string json = JsonConvert.SerializeObject(anyObject);
Message message = new Message(Encoding.UTF8.GetBytes(json));
ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository();
specificationsRepository
.GetSpecificationById(Arg.Is(SpecificationId))
.Returns((Specification)null);
SpecificationsService service = CreateService(specificationsRepository: specificationsRepository);
//Act
Func <Task> test = async() => await service.Process(message);
//Assert
test
.Should().ThrowExactly <InvalidModelException>();
}
public void Validate_GivenValidModelWithBaselineCalculationHasSpecificationThatDoesNotExist_ValidIsFalse()
{
//Arrange
CalculationEditModel model = CreateModel();
model.CalculationType = CalculationType.Baseline;
ISpecificationsRepository specsRepo = CreateSpecificationsRepository(false);
Specification specification = null;
specsRepo
.GetSpecificationById(specificationId)
.Returns(specification);
CalculationEditModelValidator validator = CreateValidator(specsRepo);
//Act
ValidationResult result = validator.Validate(model);
//Assert
result
.IsValid
.Should()
.BeFalse();
IEnumerable <string> expectedErrors = new[] { "Specification not found", "Unable to find Allocation Line with provided ID" };
result.Errors.Count().Should().Be(expectedErrors.Count());
foreach (string error in expectedErrors)
{
result.Errors.Count(e => e.ErrorMessage == error).Should().Be(1);
}
}
public async Task SelectSpecificationForFunding_GivenSpecificationFoundButAlreadySelected_ReturnsNoContentResult()
{
//Arrange
Specification specification = CreateSpecification();
specification.IsSelectedForFunding = true;
ILogger logger = CreateLogger();
ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository();
specificationsRepository
.GetSpecificationById(Arg.Is(SpecificationId))
.Returns(specification);
SpecificationsService service = CreateService(logs: logger, specificationsRepository: specificationsRepository);
//Act
IActionResult result = await service.SelectSpecificationForFunding(SpecificationId);
//Assert
result
.Should()
.BeOfType <NoContentResult>();
logger
.Received(1)
.Warning(Arg.Is($"Attempt to mark specification with id: {SpecificationId} selected when already selected"));
}
public async Task RefreshPublishResults_GivenSingleSpecificationId_ShouldReturnNoContentResult()
{
// Arrange
const string specificationId1 = "123";
HttpRequest httpRequest = Substitute.For <HttpRequest>();
ISpecificationsRepository mockSpecificationsRepository = Substitute.For <ISpecificationsRepository>();
mockSpecificationsRepository.GetSpecificationById(Arg.Any <string>()).Returns(new Specification());
SpecificationCalculationExecutionStatus expectedSpecificationStatusCall1 = new SpecificationCalculationExecutionStatus(specificationId1, 0, CalculationProgressStatus.NotStarted);
ICacheProvider mockCacheProvider = Substitute.For <ICacheProvider>();
IJobsApiClient jobsApiClient = CreateJobsApiClient();
SpecificationsService specificationsService = CreateService(specificationsRepository: mockSpecificationsRepository,
cacheProvider: mockCacheProvider, jobsApiClient: jobsApiClient);
httpRequest.Query.Returns(new QueryCollection(new Dictionary <string, StringValues>()
{
{ "specificationId", new StringValues($"{specificationId1}") }
}));
// Act
IActionResult actionResultReturned = await specificationsService.RefreshPublishedResults(httpRequest);
// Assert
actionResultReturned.Should().BeOfType <NoContentResult>();
await mockCacheProvider.Received().SetAsync($"{CalculationProgressPrependKey}{specificationId1}", expectedSpecificationStatusCall1, TimeSpan.FromHours(6), false);
await jobsApiClient.Received(1).CreateJob(Arg.Is <JobCreateModel>(j => j.JobDefinitionId == JobConstants.DefinitionNames.PublishProviderResultsJob && j.SpecificationId == specificationId1 && j.Trigger.Message == $"Refreshing published provider results for specification"));
}
public async Task GetPublishDates_SpecDoesNotExistsInSystem_Returns412WithErrorMessage()
{
//Arrange
ILogger logger = CreateLogger();
string specificationId = "test";
string expectedErrorMessage = $"No specification ID {specificationId} were returned from the repository, result came back null";
ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository();
specificationsRepository
.GetSpecificationById(specificationId)
.Returns <Specification>(x => null);
SpecificationsService service = CreateService(logs: logger, specificationsRepository: specificationsRepository);
// Act
IActionResult result = await service.GetPublishDates(specificationId);
//Assert
result
.Should()
.BeOfType <PreconditionFailedResult>()
.Which
.Value
.Should()
.Be(expectedErrorMessage);
logger
.Received(1)
.Error(Arg.Is(expectedErrorMessage));
}
public async Task SelectSpecificationForFunding_GivenNoFundingStreamAlreadySelectedInPeriod_ReturnsConflict()
{
Specification specification = CreateSpecification();
Specification specificationWithFundingStreamClash = CreateSpecification();
SpecificationVersion currentVersionOfSpecification = specification.Current;
string commonFundingStreamId = currentVersionOfSpecification.FundingStreams.First().Id;
specificationWithFundingStreamClash.Current.FundingStreams.First().Id = commonFundingStreamId;
ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository();
specificationsRepository
.GetSpecificationById(SpecificationId)
.Returns(specification);
specificationsRepository
.GetSpecificationsSelectedForFundingByPeriod(currentVersionOfSpecification.FundingPeriod.Id)
.Returns(new[] { specificationWithFundingStreamClash });
IActionResult result = await CreateService(
logs : CreateLogger(),
specificationsRepository : specificationsRepository)
.SelectSpecificationForFunding(SpecificationId);
result
.Should()
.BeOfType <ConflictResult>();
}
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_GivenSpecificationCouldNotBeFound_ReturnsNotFoundObjectResult()
{
//Arrange
ILogger logger = CreateLogger();
ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository();
specificationsRepository
.GetSpecificationById(Arg.Is(SpecificationId))
.Returns((Specification)null);
SpecificationsService service = CreateService(logs: logger, specificationsRepository: specificationsRepository);
//Act
IActionResult result = await service.SelectSpecificationForFunding(SpecificationId);
//Assert
result
.Should()
.BeOfType <NotFoundObjectResult>()
.Which
.Value
.Should()
.Be($"Specification not found for id: {SpecificationId}");
logger
.Received(1)
.Warning(Arg.Is($"Specification not found for id: {SpecificationId}"));
}
public void Validate_ValidatesAsExpected(CalculationCreateModel model, bool expectedResult, IEnumerable <string> expectedErrors)
{
//Arrange
ISpecificationsRepository specsRepo = CreateSpecificationsRepository(false);
Specification specification = new Specification
{
Current = new SpecificationVersion()
};
specsRepo
.GetSpecificationById(specificationId)
.Returns(specification);
CalculationCreateModelValidator validator = CreateValidator(specsRepo);
//Act
ValidationResult result = validator.Validate(model);
//Assert
result
.IsValid
.Should()
.Be(expectedResult);
foreach (var error in expectedErrors)
{
result.Errors.Count(e => e.ErrorMessage == error).Should().Be(1, $"Expected to find error message '{error}'");
}
result
.Errors
.Count
.Should()
.Be(expectedErrors.Count());
}
public async Task RefreshPublishResults_GivenValidRequestParameters_ShouldReturnNoContentResult()
{
// Arrange
const string specificationId = "123";
HttpRequest httpRequest = Substitute.For <HttpRequest>();
ISpecificationsRepository mockSpecificationsRepository = Substitute.For <ISpecificationsRepository>();
mockSpecificationsRepository.GetSpecificationById(Arg.Any <string>()).Returns(new Specification());
SpecificationCalculationExecutionStatus expectedSpecificationStatusCall1 = new SpecificationCalculationExecutionStatus(specificationId, 0, CalculationProgressStatus.NotStarted);
ICacheProvider mockCacheProvider = Substitute.For <ICacheProvider>();
SpecificationsService specificationsService = CreateService(specificationsRepository: mockSpecificationsRepository,
cacheProvider: mockCacheProvider);
httpRequest.Query.Returns(new QueryCollection(new Dictionary <string, StringValues>()
{
{ "specificationId", new StringValues(specificationId) }
}));
// Act
IActionResult actionResultReturned = await specificationsService.RefreshPublishedResults(httpRequest);
// Assert
actionResultReturned.Should().BeOfType <NoContentResult>();
await mockCacheProvider.Received().SetAsync($"{CalculationProgressPrependKey}{specificationId}", expectedSpecificationStatusCall1, TimeSpan.FromHours(6), false);
}
public async Task RefreshPublishResults_GivenASpecificationIdThatDoesNotExistAndFeatureToggleIsFalse_ShouldReturnBadRequestObjectResult()
{
// Arrange
const string validSpecificationId = "123";
const string invalidSpecificationId = "333";
IMessengerService messengerService = Substitute.For <IMessengerService>();
ISpecificationsRepository mockSpecificationsRepository = Substitute.For <ISpecificationsRepository>();
mockSpecificationsRepository.GetSpecificationById(validSpecificationId).Returns(new Specification());
SpecificationsService specificationsService = CreateService(messengerService: messengerService);
HttpRequest httpRequest = Substitute.For <HttpRequest>();
httpRequest.Query.Returns(new QueryCollection(new Dictionary <string, StringValues>()
{
{ "specificationIds", new StringValues($"{validSpecificationId}, {invalidSpecificationId}") }
}));
// Act
IActionResult actionResultReturned = await specificationsService.RefreshPublishedResults(httpRequest);
// Assert
actionResultReturned.Should().BeOfType <BadRequestObjectResult>();
}
public async Task EditSpecificationStatus_GivenSpecificationWasNotFound_ReturnsNotFoundResult()
{
//Arrange
EditStatusModel specificationEditStatusModel = new EditStatusModel
{
PublishStatus = PublishStatus.Approved
};
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();
ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository();
specificationsRepository
.GetSpecificationById(Arg.Is(SpecificationId))
.Returns((Specification)null);
SpecificationsService service = CreateService(logs: logger, specificationsRepository: specificationsRepository);
//Act
IActionResult result = await service.EditSpecificationStatus(request);
//Arrange
result
.Should()
.BeOfType <NotFoundObjectResult>()
.Which
.Value
.Should()
.Be("Specification not found");
logger
.Received(1)
.Warning(Arg.Is($"Failed to find specification for id: {SpecificationId}"));
}
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 CreateCalculation_GivenValidModelButNoPolicyFound_ReturnsPreconditionFailed()
{
//Arrange
Specification specification = new Specification()
{
Current = new SpecificationVersion(),
};
CalculationCreateModel model = new CalculationCreateModel
{
SpecificationId = SpecificationId,
PolicyId = PolicyId
};
string json = JsonConvert.SerializeObject(model);
byte[] byteArray = Encoding.UTF8.GetBytes(json);
MemoryStream stream = new MemoryStream(byteArray);
HttpRequest request = Substitute.For <HttpRequest>();
request
.Body
.Returns(stream);
ILogger logger = CreateLogger();
ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository();
specificationsRepository
.GetSpecificationById(Arg.Is(SpecificationId))
.Returns(specification);
Calculation calculation = new Calculation();
IMapper mapper = CreateMapper();
mapper
.Map <Calculation>(model)
.Returns(calculation);
SpecificationsService service = CreateService(logs: logger, specificationsRepository: specificationsRepository, mapper: mapper);
//Act
IActionResult result = await service.CreateCalculation(request);
//Assert
result
.Should()
.BeOfType <PreconditionFailedResult>()
.Which
.Value
.Should()
.Be("Policy not found for policy id 'dda8ccb3-eb8e-4658-8b3f-f1e4c3a8f322'");
logger
.Received(1)
.Warning($"Policy not found for policy id '{PolicyId}'");
}
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 CreateCalculation_GivenDuplicateCalculationName_ReturnsBadRequest()
{
// Arrange
Specification specification = CreateSpecification();
CalculationCreateModel model = new CalculationCreateModel
{
SpecificationId = SpecificationId,
PolicyId = PolicyId,
Name = "calc1",
CalculationType = CalculationType.Number
};
string json = JsonConvert.SerializeObject(model);
byte[] byteArray = Encoding.UTF8.GetBytes(json);
MemoryStream stream = new MemoryStream(byteArray);
ClaimsPrincipal principal = new ClaimsPrincipal(new[]
{
new ClaimsIdentity(new [] { new Claim(ClaimTypes.Sid, UserId), new Claim(ClaimTypes.Name, Username) })
});
HttpContext context = Substitute.For <HttpContext>();
context
.User
.Returns(principal);
HttpRequest request = Substitute.For <HttpRequest>();
request
.Body
.Returns(stream);
request
.HttpContext
.Returns(context);
ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository();
specificationsRepository
.GetSpecificationById(Arg.Is(SpecificationId))
.Returns(specification);
IValidator <CalculationCreateModel> validator = CreateCalculationValidator(new ValidationResult(new[] { new ValidationFailure("prop1", "any error") }));
SpecificationsService service = CreateService(specificationsRepository: specificationsRepository,
calculationCreateModelValidator: validator);
// Act
IActionResult result = await service.CreateCalculation(request);
// Assert
result
.Should()
.BeOfType <BadRequestObjectResult>();
}
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 EditSpecification_GivenSpecificationWasfoundAndFundingPeriodChangedButFailedToGetFundingPeriodsFromCosmos_ReturnsPreConditionFailedresult()
{
//Arrange
SpecificationEditModel specificationEditModel = new SpecificationEditModel
{
FundingPeriodId = "fp10"
};
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);
SpecificationsService service = CreateService(logs: logger, specificationsRepository: specificationsRepository);
//Act
IActionResult result = await service.EditSpecification(request);
//Arrange
result
.Should()
.BeOfType <PreconditionFailedResult>()
.Which
.Value
.Should()
.Be($"Unable to find funding period with ID '{specificationEditModel.FundingPeriodId}'.");
}
public async Task EditPolicy_WhenValidModelButPolicyCouldNotBeFound_ThenReturnsNotFoundResult()
{
// Arrange
PolicyEditModel policyEditModel = new PolicyEditModel
{
SpecificationId = SpecificationId
};
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();
ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository();
specificationsRepository
.GetSpecificationById(Arg.Is(SpecificationId))
.Returns(specification);
SpecificationsService specificationsService = CreateService(specificationsRepository: specificationsRepository);
// Act
IActionResult result = await specificationsService.EditPolicy(request);
// Assert
result
.Should()
.BeOfType <NotFoundObjectResult>()
.Which
.Value
.Should()
.Be($"Failed to find policy for policy id: {PolicyId}");
}
public async Task GetPolicyByName_GivenSpecificationExistsAndPolicyExists_ReturnsSuccess()
{
//Arrange
Specification spec = new Specification
{
Current = new SpecificationVersion()
{
Policies = new[]
{
new Policy {
Name = PolicyName
}
},
},
};
PolicyGetModel model = new PolicyGetModel
{
SpecificationId = SpecificationId,
Name = PolicyName
};
string json = JsonConvert.SerializeObject(model);
byte[] byteArray = Encoding.UTF8.GetBytes(json);
MemoryStream stream = new MemoryStream(byteArray);
HttpRequest request = Substitute.For <HttpRequest>();
request
.Body
.Returns(stream);
ILogger logger = CreateLogger();
ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository();
specificationsRepository
.GetSpecificationById(Arg.Is(SpecificationId))
.Returns(spec);
SpecificationsService service = CreateService(specificationsRepository: specificationsRepository, logs: logger);
//Act
IActionResult result = await service.GetPolicyByName(request);
//Assert
result
.Should()
.BeOfType <OkObjectResult>();
logger
.Received(1)
.Information(Arg.Is($"A policy was found for specification id {SpecificationId} and name {PolicyName}"));
}
public async Task GetSpecificationSummaryById_GivenSpecificationSummaryWasNotFound_ReturnsNotFoundResult()
{
//Arrange
Specification specification = null;
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);
IMapper mapper = CreateImplementedMapper();
ICacheProvider cacheProvider = CreateCacheProvider();
cacheProvider
.GetAsync <SpecificationSummary>(Arg.Is($"{CacheKeys.SpecificationSummaryById}{SpecificationId}"))
.Returns((SpecificationSummary)null);
SpecificationsService service = CreateService(
specificationsRepository: specificationsRepository,
cacheProvider: cacheProvider,
logs: logger,
mapper: mapper);
//Act
IActionResult result = await service.GetSpecificationSummaryById(request);
//Assert
result
.Should()
.BeOfType <NotFoundResult>();
await specificationsRepository
.Received(1)
.GetSpecificationById(Arg.Is(SpecificationId));
await cacheProvider
.Received(1)
.GetAsync <SpecificationSummary>(Arg.Is($"{CacheKeys.SpecificationSummaryById}{SpecificationId}"));
}
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 EditCalculation_WhenValidModelButSpecificationCouldNotBeFound_ThenReturnsPreConditionFailed()
{
// Arrange
CalculationEditModel policyEditModel = new CalculationEditModel();
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);
ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository();
specificationsRepository
.GetSpecificationById(Arg.Is(SpecificationId))
.Returns((Specification)null);
SpecificationsService specificationsService = CreateService(specificationsRepository: specificationsRepository);
// Act
IActionResult result = await specificationsService.EditCalculation(request);
// Assert
result
.Should()
.BeOfType <PreconditionFailedResult>()
.Which
.Value
.Should()
.Be($"Specification not found for specification id {SpecificationId}");
}
public void Validate_GivenNameAlreadyExists_ValidIsFalse()
{
//Arrange
CalculationEditModel model = CreateModel();
ISpecificationsRepository repository = CreateSpecificationsRepository(true);
Specification specification = new Specification()
{
Current = new SpecificationVersion()
};
repository
.GetSpecificationById(specificationId)
.Returns(specification);
ICalculationsRepository calculationsRepository = Substitute.For <ICalculationsRepository>();
calculationsRepository
.IsCalculationNameValid(Arg.Any <string>(), Arg.Any <string>(), Arg.Any <string>())
.Returns(false);
CalculationEditModelValidator validator = CreateValidator(repository, calculationsRepository);
//Act
ValidationResult result = validator.Validate(model);
//Assert
result
.IsValid
.Should()
.BeFalse();
result
.Errors
.Count
.Should()
.Be(1);
result
.Errors
.Single()
.ErrorMessage
.Should()
.Be("Calculation with the same generated source code name already exists in this specification");
calculationsRepository
.Received(1)
.IsCalculationNameValid(specificationId, name, calculationId);
}
public AssignSpecificationProviderVersionModelValidator(
ISpecificationsRepository specificationsRepository,
IProvidersApiClient providersApiClient,
ISpecificationsResiliencePolicies resiliencePolicies)
{
Guard.ArgumentNotNull(specificationsRepository, nameof(specificationsRepository));
Guard.ArgumentNotNull(providersApiClient, nameof(providersApiClient));
Guard.ArgumentNotNull(resiliencePolicies?.ProvidersApiClient, nameof(resiliencePolicies.ProvidersApiClient));
_specificationsRepository = specificationsRepository;
_providersApiClient = providersApiClient;
_providersApiClientPolicy = resiliencePolicies.ProvidersApiClient;
RuleFor(model => model.SpecificationId)
.NotEmpty()
.WithMessage("Null or Empty SpecificationId provided")
.CustomAsync(async(name, context, cancellationToken) =>
{
AssignSpecificationProviderVersionModel model = context.ParentContext.InstanceToValidate as AssignSpecificationProviderVersionModel;
if (!string.IsNullOrWhiteSpace(model.SpecificationId))
{
Specification specification = await _specificationsRepository.GetSpecificationById(model.SpecificationId);
if (specification == null)
{
context.AddFailure(nameof(model.SpecificationId), $"Specification not found for SpecificationId - {model.SpecificationId}");
}
else if (specification.Current.ProviderSource != ProviderSource.FDZ)
{
context.AddFailure($"Specification ProviderSource is not set to FDZ");
}
}
});
RuleFor(model => model.ProviderVersionId)
.NotEmpty()
.WithMessage("Null or Empty ProviderVersionId provided")
.CustomAsync(async(name, context, cancellationToken) =>
{
AssignSpecificationProviderVersionModel model = context.ParentContext.InstanceToValidate as AssignSpecificationProviderVersionModel;
if (!string.IsNullOrWhiteSpace(model.ProviderVersionId))
{
HttpStatusCode providerVersionStatusCode = await _providersApiClientPolicy.ExecuteAsync(() => _providersApiClient.DoesProviderVersionExist(model.ProviderVersionId));
if (providerVersionStatusCode == HttpStatusCode.NotFound)
{
context.AddFailure(nameof(model.ProviderVersionId), $"Provider version id specified does not exist");
}
}
});
}
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 GetPolicyByName_GivenSpecificationDoesNotExist_ReturnsPreConditionFailed()
{
//Arrange
PolicyGetModel model = new PolicyGetModel
{
SpecificationId = SpecificationId,
Name = PolicyName
};
string json = JsonConvert.SerializeObject(model);
byte[] byteArray = Encoding.UTF8.GetBytes(json);
MemoryStream stream = new MemoryStream(byteArray);
HttpRequest request = Substitute.For <HttpRequest>();
request
.Body
.Returns(stream);
ILogger logger = CreateLogger();
ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository();
specificationsRepository
.GetSpecificationById(Arg.Is(SpecificationId))
.Returns((Specification)null);
SpecificationsService service = CreateService(specificationsRepository: specificationsRepository, logs: logger);
//Act
IActionResult result = await service.GetPolicyByName(request);
//Assert
result
.Should()
.BeOfType <StatusCodeResult>();
StatusCodeResult statusCodeResult = (StatusCodeResult)result;
statusCodeResult
.StatusCode
.Should()
.Be(412);
logger
.Received(1)
.Error(Arg.Is($"No specification was found for specification id {SpecificationId}"));
}
