public async Task GetPublishedProviderResultWithHistoryByAllocationResultId_GivenResultFoundButNoHistory_ResturnsNull()
{
//Arrange
string allocationResultId = "12345";
string query = $"select c from c where c.documentType = 'PublishedAllocationLineResultVersion' and c.deleted = false and c.content.entityId = '{allocationResultId}'";
PublishedProviderResult publishedProviderResult = new PublishedProviderResult {
ProviderId = "1111"
};
IPublishedProviderResultsRepository publishedProviderResultsRepository = CreatePublishedProviderResultsRepository();
publishedProviderResultsRepository
.GetPublishedProviderResultForIdInPublishedState(Arg.Is(allocationResultId))
.Returns(publishedProviderResult);
IVersionRepository <PublishedAllocationLineResultVersion> versionRepository = CreatePublishedProviderResultsVersionRepository();
versionRepository
.GetVersions(Arg.Is(query), Arg.Is("1111"))
.Returns((IEnumerable <PublishedAllocationLineResultVersion>)null);
PublishedResultsService service = CreateResultsService(publishedProviderResultsRepository: publishedProviderResultsRepository, publishedProviderResultsVersionRepository: versionRepository);
//Act
PublishedProviderResultWithHistory result = await service.GetPublishedProviderResultWithHistoryByAllocationResultId(allocationResultId);
//Assert
result
.Should()
.BeNull();
}
public void GetPublishedProviderResultVersionById_GivenVersionWasFound_ReturnsVersion()
{
//Arrange
string feedIndexId = "id-1";
PublishedAllocationLineResultVersion publishedAllocationLineResultVersion = new PublishedAllocationLineResultVersion();
IPublishedProviderResultsRepository publishedProviderResultsRepository = CreatePublishedProviderResultsRepository();
publishedProviderResultsRepository
.GetPublishedProviderResultVersionForFeedIndexId(Arg.Is(feedIndexId))
.Returns(publishedAllocationLineResultVersion);
PublishedResultsService publishedResultsService = CreateResultsService(publishedProviderResultsRepository: publishedProviderResultsRepository);
//Act
PublishedAllocationLineResultVersion result = publishedResultsService.GetPublishedProviderResultVersionById(feedIndexId);
//Assert
result
.Should()
.NotBeNull();
result
.Should()
.Be(publishedAllocationLineResultVersion);
}
public async Task GetConfirmationDetailsForApprovePublishProviderResults_GivenNoUpdateModelProvided_ReturnsBadRequest()
{
//arrange
IQueryCollection queryStringValues = new QueryCollection(new Dictionary <string, StringValues>
{
{ "specificationId", new StringValues(specificationId) },
});
HttpRequest request = Substitute.For <HttpRequest>();
request
.Query
.Returns(queryStringValues);
ILogger logger = CreateLogger();
PublishedResultsService resultsService = CreateResultsService(logger);
//Act
IActionResult actionResult = await resultsService.GetConfirmationDetailsForApprovePublishProviderResults(request);
//Arrange
actionResult
.Should()
.BeOfType <BadRequestObjectResult>()
.Which
.Value
.Should()
.Be("Null filterCriteria was provided");
logger
.Received(1)
.Error("Null filterCriteria was provided to GetConfirmationDetailsForApprovePublishProviderResults");
}
public async Task GetPublishedProviderResultsBySpecificationId_GivenNoSpecificationIdProvided_ReturnsBadRequest()
{
//Arrange
HttpRequest request = Substitute.For <HttpRequest>();
ILogger logger = CreateLogger();
PublishedResultsService resultsService = CreateResultsService(logger);
//Act
IActionResult actionResult = await resultsService.GetPublishedProviderResultsBySpecificationId(request);
//Arrange
actionResult
.Should()
.BeOfType <BadRequestObjectResult>()
.Which
.Value
.Should()
.Be("Null or empty specification Id provided");
logger
.Received(1)
.Error("No specification Id was provided to GetPublishedProviderResultsBySpecificationId");
}
public async Task GetPublishedProviderResultsByFundingPeriodIdAndSpecificationIdAndFundingPeriodId_GivenNoFundingPeriodIdProvided_ReturnsBadRequest()
{
//Arrange
IQueryCollection queryStringValues = new QueryCollection(new Dictionary <string, StringValues>
{
{ "specificationId", new StringValues(specificationId) },
{ "fundingStreamId", new StringValues(fundingStreamId) },
});
HttpRequest request = Substitute.For <HttpRequest>();
request
.Query
.Returns(queryStringValues);
ILogger logger = CreateLogger();
PublishedResultsService resultsService = CreateResultsService(logger);
//Act
IActionResult actionResult = await resultsService.GetPublishedProviderResultsByFundingPeriodIdAndSpecificationIdAndFundingStreamId(request);
//Arrange
actionResult
.Should()
.BeOfType <BadRequestObjectResult>()
.Which
.Value
.Should()
.Be("Null or empty fundingPeriod Id provided");
logger
.Received(1)
.Error("No fundingPeriod Id was provided to GetPublishedProviderResultsByFundingPeriodIdAndSpecificationIdAndFundingStreamId");
}
public async Task GetPublishedProviderResultsBySpecificationId_GivenNoProviderResultsFound_ReturnsEmptyList()
{
//arrange
IQueryCollection queryStringValues = new QueryCollection(new Dictionary <string, StringValues>
{
{ "specificationId", new StringValues(specificationId) },
});
HttpRequest request = Substitute.For <HttpRequest>();
request
.Query
.Returns(queryStringValues);
IPublishedProviderResultsRepository publishedProviderResultsRepository = CreatePublishedProviderResultsRepository();
PublishedResultsService resultsService = CreateResultsService(publishedProviderResultsRepository: publishedProviderResultsRepository);
//Act
IActionResult actionResult = await resultsService.GetPublishedProviderResultsBySpecificationId(request);
//Assert
actionResult
.Should()
.BeOfType <OkObjectResult>();
}
public async Task ReIndexAllocationNotificationFeeds_GivenNoPublishedProviderResultsFound_LogsWarning()
{
//Arrange
Message message = new Message();
IEnumerable <PublishedProviderResult> results = Enumerable.Empty <PublishedProviderResult>();
IPublishedProviderResultsRepository repository = CreatePublishedProviderResultsRepository();
repository
.GetAllNonHeldPublishedProviderResults()
.Returns(results);
ILogger logger = CreateLogger();
PublishedResultsService resultsService = CreateResultsService(logger, publishedProviderResultsRepository: repository);
//Act
await resultsService.ReIndexAllocationNotificationFeeds(message);
//Assert
logger
.Received()
.Warning(Arg.Is("No published provider results were found to index."));
logger
.Received(1)
.Information($"{nameof(resultsService.ReIndexAllocationNotificationFeeds)} initiated by: 'system'");
}
public async Task ReIndexAllocationNotificationFeeds_GivenMessageWithUserDetails_LogsInitiated()
{
//Arrange
string userName = "******";
Message message = new Message();
message.UserProperties["user-id"] = "123";
message.UserProperties["user-name"] = userName;
IEnumerable <PublishedProviderResult> results = Enumerable.Empty <PublishedProviderResult>();
IPublishedProviderResultsRepository repository = CreatePublishedProviderResultsRepository();
repository
.GetAllNonHeldPublishedProviderResults()
.Returns(results);
ILogger logger = CreateLogger();
PublishedResultsService resultsService = CreateResultsService(logger, publishedProviderResultsRepository: repository);
//Act
await resultsService.ReIndexAllocationNotificationFeeds(message);
//Assert
logger
.Received(1)
.Information($"{nameof(resultsService.ReIndexAllocationNotificationFeeds)} initiated by: '{userName}'");
}
public void GetPublishedProviderResultByVersionId_GivenVersionFoundButResultCanbnotBeFound_ReturnsNull()
{
//Arrange
string id = "id-1";
string entityId = "entity-id-1";
PublishedAllocationLineResultVersion version = new PublishedAllocationLineResultVersion
{
PublishedProviderResultId = entityId,
FeedIndexId = id
};
IPublishedProviderResultsRepository publishedProviderResultsRepository = CreatePublishedProviderResultsRepository();
publishedProviderResultsRepository
.GetPublishedProviderResultVersionForFeedIndexId(Arg.Is(id))
.Returns(version);
publishedProviderResultsRepository
.GetPublishedProviderResultForId(Arg.Is(entityId))
.Returns((PublishedProviderResult)null);
PublishedResultsService publishedResultsService = CreateResultsService(publishedProviderResultsRepository: publishedProviderResultsRepository);
//Act
PublishedProviderResult result = publishedResultsService.GetPublishedProviderResultByVersionId(id);
//Assert
result
.Should()
.BeNull();
}
public async Task UpdatePublishedAllocationLineResultsStatus_GivenNoUpdateModelProvided_ReturnsBadRequest()
{
//arrange
IQueryCollection queryStringValues = new QueryCollection(new Dictionary <string, StringValues>
{
{ "specificationId", new StringValues(specificationId) },
});
HttpRequest request = Substitute.For <HttpRequest>();
request
.Query
.Returns(queryStringValues);
ILogger logger = CreateLogger();
PublishedResultsService resultsService = CreateResultsService(logger);
//Act
IActionResult actionResult = await resultsService.UpdatePublishedAllocationLineResultsStatus(request);
//Arrange
actionResult
.Should()
.BeOfType <BadRequestObjectResult>()
.Which
.Value
.Should()
.Be("Null updateStatusModel was provided");
logger
.Received(1)
.Error("Null updateStatusModel was provided to UpdateAllocationLineResultStatus");
}
public async Task CreateAllocationLineResultStatusUpdateJobs_GivenJobIdButJobResponseIsNotFound_LogsAndDoesNotProcess()
{
//Arrange
Message message = new Message();
message.UserProperties.Add("jobId", jobId);
ILogger logger = CreateLogger();
ApiResponse <JobViewModel> apiResponse = new ApiResponse <JobViewModel>(HttpStatusCode.NotFound);
IJobsApiClient jobsApiClient = CreateJobsApiClient();
jobsApiClient
.GetJobById(jobId)
.Returns(apiResponse);
PublishedResultsService publishedResultsService = CreateResultsService(logger, jobsApiClient: jobsApiClient);
//Act
await publishedResultsService.CreateAllocationLineResultStatusUpdateJobs(message);
//Assert
logger
.Received(1)
.Error(Arg.Is($"Could not find the job with id: '{jobId}'"));
await jobsApiClient
.DidNotReceive()
.AddJobLog(Arg.Is(jobId), Arg.Any <JobLogUpdateModel>());
}
public async Task GetPublishedProviderResultByAllocationResultId_GivenVersionAndFoundInHistory_ReturnsResult()
{
//Arrange
string allocationResultId = "12345";
int version = 5;
PublishedProviderResult publishedProviderResult = new PublishedProviderResult
{
FundingStreamResult = new PublishedFundingStreamResult
{
AllocationLineResult = new PublishedAllocationLineResult
{
Current = new PublishedAllocationLineResultVersion {
Version = 2
}
}
}
};
PublishedAllocationLineResultVersion publishedAllocationLineResultVersion = new PublishedAllocationLineResultVersion
{
Version = 5
};
IPublishedProviderResultsRepository publishedProviderResultsRepository = CreatePublishedProviderResultsRepository();
publishedProviderResultsRepository
.GetPublishedProviderResultForIdInPublishedState(Arg.Is(allocationResultId))
.Returns(publishedProviderResult);
IVersionRepository <PublishedAllocationLineResultVersion> versionRepository = CreatePublishedProviderResultsVersionRepository();
versionRepository
.GetVersion(Arg.Is(allocationResultId), Arg.Is(version))
.Returns(publishedAllocationLineResultVersion);
PublishedResultsService service = CreateResultsService(publishedProviderResultsRepository: publishedProviderResultsRepository, publishedProviderResultsVersionRepository: versionRepository);
//Act
PublishedProviderResult result = await service.GetPublishedProviderResultByAllocationResultId(allocationResultId, version);
//Assert
result
.Should()
.NotBeNull();
result
.FundingStreamResult
.AllocationLineResult
.Current
.Version
.Should()
.Be(5);
}
public async Task GetPublishedProviderResultWithHistoryByAllocationResultId_GivenResultAndHistory_ResturnsResult()
{
//Arrange
string allocationResultId = "12345";
PublishedProviderResult publishedProviderResult = new PublishedProviderResult
{
ProviderId = "1111",
FundingStreamResult = new PublishedFundingStreamResult
{
AllocationLineResult = new PublishedAllocationLineResult {
}
}
};
IEnumerable <PublishedAllocationLineResultVersion> history = new[]
{
new PublishedAllocationLineResultVersion(),
new PublishedAllocationLineResultVersion(),
new PublishedAllocationLineResultVersion()
};
IPublishedProviderResultsRepository publishedProviderResultsRepository = CreatePublishedProviderResultsRepository();
publishedProviderResultsRepository
.GetPublishedProviderResultForIdInPublishedState(Arg.Is(allocationResultId))
.Returns(publishedProviderResult);
IVersionRepository <PublishedAllocationLineResultVersion> versionRepository = CreatePublishedProviderResultsVersionRepository();
versionRepository
.GetVersions(Arg.Is(allocationResultId), Arg.Is("1111"))
.Returns(history);
PublishedResultsService service = CreateResultsService(publishedProviderResultsRepository: publishedProviderResultsRepository, publishedProviderResultsVersionRepository: versionRepository);
//Act
PublishedProviderResultWithHistory result = await service.GetPublishedProviderResultWithHistoryByAllocationResultId(allocationResultId);
//Assert
result
.Should()
.NotBeNull();
result
.PublishedProviderResult
.Should()
.NotBeNull();
result
.History
.Count()
.Should()
.Be(3);
}
public void CreateAllocationLineResultStatusUpdateJobs_GivenJobFoundButModelNotFoundInCache_LogsAndThrowsException()
{
//Arrange
const string cacheKey = "cache-key";
Message message = new Message();
message.UserProperties.Add("jobId", jobId);
ILogger logger = CreateLogger();
JobViewModel job = new JobViewModel
{
Id = jobId,
Properties = new Dictionary <string, string>
{
{ "cache-key", cacheKey }
}
};
ApiResponse <JobViewModel> apiResponse = new ApiResponse <JobViewModel>(HttpStatusCode.OK, job);
IJobsApiClient jobsApiClient = CreateJobsApiClient();
jobsApiClient
.GetJobById(jobId)
.Returns(apiResponse);
ICacheProvider cacheProvider = CreateCacheProvider();
cacheProvider
.GetAsync <UpdatePublishedAllocationLineResultStatusModel>(Arg.Is(cacheKey))
.Returns((UpdatePublishedAllocationLineResultStatusModel)null);
PublishedResultsService publishedResultsService = CreateResultsService(logger, jobsApiClient: jobsApiClient, cacheProvider: cacheProvider);
//Act
Func <Task> test = async() => await publishedResultsService.CreateAllocationLineResultStatusUpdateJobs(message);
//Assert
test
.Should()
.ThrowExactly <Exception>()
.Which
.Message
.Should()
.Be($"Could not find the update model in cache with cache key: '{cacheKey}'");
logger
.Received(1)
.Error(Arg.Is($"Could not find the update model in cache with cache key: '{cacheKey}'"));
}
public void GetPublishedProviderResultByVersionId_GivenResultFound_ReturnsResult()
{
//Arrange
string id = "id-1";
string entityId = "entity-id-1";
PublishedAllocationLineResultVersion version = new PublishedAllocationLineResultVersion
{
PublishedProviderResultId = entityId,
FeedIndexId = id
};
PublishedProviderResult publishedProviderResult = new PublishedProviderResult
{
FundingStreamResult = new PublishedFundingStreamResult
{
AllocationLineResult = new PublishedAllocationLineResult()
}
};
IPublishedProviderResultsRepository publishedProviderResultsRepository = CreatePublishedProviderResultsRepository();
publishedProviderResultsRepository
.GetPublishedProviderResultVersionForFeedIndexId(Arg.Is(id))
.Returns(version);
publishedProviderResultsRepository
.GetPublishedProviderResultForId(Arg.Is(entityId))
.Returns(publishedProviderResult);
PublishedResultsService publishedResultsService = CreateResultsService(publishedProviderResultsRepository: publishedProviderResultsRepository);
//Act
PublishedProviderResult result = publishedResultsService.GetPublishedProviderResultByVersionId(id);
//Assert
result
.Should()
.NotBeNull();
result
.FundingStreamResult
.AllocationLineResult
.Current
.Should()
.Be(version);
}
public async Task GetPublishedProviderResultsByFundingPeriodIdAndSpecificationIdAndFundingStreamId_GivenProviderResultsFound_ReturnsAllocationResultsOrderedByAllocationName()
{
// Arrange
IQueryCollection queryStringValues = new QueryCollection(new Dictionary <string, StringValues>
{
{ "specificationId", new StringValues(specificationId) },
{ "fundingPeriodId", new StringValues(fundingPeriodId) },
{ "fundingStreamId", new StringValues(fundingStreamId) },
});
HttpRequest request = Substitute.For <HttpRequest>();
request
.Query
.Returns(queryStringValues);
IEnumerable <PublishedProviderResultByAllocationLineViewModel> publishedProviderResults = CreatePublishedProviderResultByAllocationLineViewModelWithMultipleAllocationLines();
IPublishedProviderResultsRepository publishedProviderResultsRepository = CreatePublishedProviderResultsRepository();
publishedProviderResultsRepository
.GetPublishedProviderResultsSummaryByFundingPeriodIdAndSpecificationIdAndFundingStreamId(Arg.Is(fundingPeriodId), Arg.Is(specificationId), Arg.Is(fundingStreamId))
.Returns(publishedProviderResults);
PublishedResultsService resultsService = CreateResultsService(publishedProviderResultsRepository: publishedProviderResultsRepository);
// Act
IActionResult actionResult = await resultsService.GetPublishedProviderResultsByFundingPeriodIdAndSpecificationIdAndFundingStreamId(request);
// Assert
actionResult
.Should()
.BeOfType <OkObjectResult>();
OkObjectResult okObjectResult = actionResult as OkObjectResult;
IEnumerable <PublishedProviderResultModel> publishedProviderResultModels = okObjectResult.Value as IEnumerable <PublishedProviderResultModel>;
publishedProviderResultModels
.Count()
.Should()
.Be(1);
IEnumerable <string> allocationResultNames = publishedProviderResultModels.First().FundingStreamResults.First().AllocationLineResults.Select(r => r.AllocationLineName);
allocationResultNames.Should().BeInAscendingOrder();
}
public async Task GetPublishedProviderProfileForProviderIdAndSpecificationIdAndFundingStreamId_RepoReturnsEmpty_ReturnsNotFoundResult()
{
string providerId = "123";
string specificationId = "456";
string fundingStreamId = "789";
IPublishedProviderResultsRepository publishedProviderResultsRepository = Substitute.For <IPublishedProviderResultsRepository>();
PublishedResultsService service = CreateResultsService(publishedProviderResultsRepository: publishedProviderResultsRepository);
IActionResult result = await service.GetPublishedProviderProfileForProviderIdAndSpecificationIdAndFundingStreamId(providerId, specificationId, fundingStreamId);
await publishedProviderResultsRepository
.Received(1)
.GetPublishedProviderProfileForProviderIdAndSpecificationIdAndFundingStreamId(providerId, specificationId, fundingStreamId);
result.Should().BeOfType <NotFoundResult>();
}
public async Task ReIndexAllocationNotificationFeeds_GivenPublishedProviderFoundButAllHeld_DoesNotIndexReturnsContentResult()
{
//Arrange
Message message = new Message();
IPublishedProviderResultsRepository repository = CreatePublishedProviderResultsRepository();
repository
.GetAllNonHeldPublishedProviderResults()
.Returns(Enumerable.Empty <PublishedProviderResult>());
ILogger logger = CreateLogger();
ISearchRepository <AllocationNotificationFeedIndex> searchRepository = CreateAllocationNotificationFeedSearchRepository();
SpecificationCurrentVersion specification = CreateSpecification(specificationId);
ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository();
specificationsRepository
.GetCurrentSpecificationById(Arg.Is("spec-1"))
.Returns(specification);
PublishedResultsService resultsService = CreateResultsService(logger, publishedProviderResultsRepository: repository,
allocationNotificationFeedSearchRepository: searchRepository, specificationsRepository: specificationsRepository);
//Act
await resultsService.ReIndexAllocationNotificationFeeds(message);
//Assert
await
searchRepository
.DidNotReceive()
.Index(Arg.Any <IEnumerable <AllocationNotificationFeedIndex> >());
logger
.Received(1)
.Warning(Arg.Is("No published provider results were found to index."));
await
repository
.Received(0)
.GetAllNonHeldPublishedProviderResultVersions(Arg.Any <string>(), Arg.Any <string>());
}
public async Task GetPublishedProviderResultByAllocationResultId_GivenVersionSuppliedButAlreadyCurrent_ReturnsResultDoesNotFetchHistory()
{
//Arrange
string allocationResultId = "12345";
int version = 1;
PublishedProviderResult publishedProviderResult = new PublishedProviderResult
{
FundingStreamResult = new PublishedFundingStreamResult
{
AllocationLineResult = new PublishedAllocationLineResult
{
Current = new PublishedAllocationLineResultVersion {
Version = version
}
}
}
};
IPublishedProviderResultsRepository publishedProviderResultsRepository = CreatePublishedProviderResultsRepository();
publishedProviderResultsRepository
.GetPublishedProviderResultForIdInPublishedState(Arg.Is(allocationResultId))
.Returns(publishedProviderResult);
IVersionRepository <PublishedAllocationLineResultVersion> versionRepository = CreatePublishedProviderResultsVersionRepository();
PublishedResultsService service = CreateResultsService(publishedProviderResultsRepository: publishedProviderResultsRepository, publishedProviderResultsVersionRepository: versionRepository);
//Act
PublishedProviderResult result = await service.GetPublishedProviderResultByAllocationResultId(allocationResultId, version);
//Assert
result
.Should()
.NotBeNull();
await
versionRepository
.DidNotReceive()
.GetVersion(Arg.Any <string>(), Arg.Any <int>());
}
public async Task UpdatePublishedAllocationLineResultsStatus_GivenUpdateModelWithNoProviders_ReturnsBadRequest()
{
//arrange
IQueryCollection queryStringValues = new QueryCollection(new Dictionary <string, StringValues>
{
{ "specificationId", new StringValues(specificationId) },
});
UpdatePublishedAllocationLineResultStatusModel model = new UpdatePublishedAllocationLineResultStatusModel();
string json = JsonConvert.SerializeObject(model);
byte[] byteArray = Encoding.UTF8.GetBytes(json);
MemoryStream stream = new MemoryStream(byteArray);
HttpRequest request = Substitute.For <HttpRequest>();
request
.Query
.Returns(queryStringValues);
request
.Body
.Returns(stream);
ILogger logger = CreateLogger();
PublishedResultsService resultsService = CreateResultsService(logger);
//Act
IActionResult actionResult = await resultsService.UpdatePublishedAllocationLineResultsStatus(request);
//Arrange
actionResult
.Should()
.BeOfType <BadRequestObjectResult>()
.Which
.Value
.Should()
.Be("Null or empty providers was provided");
logger
.Received(1)
.Error("Null or empty providers was provided to UpdateAllocationLineResultStatus");
}
public async Task ReIndexAllocationNotificationFeeds_GivenRequest_AddsServiceBusMessage()
{
//Arrange
string userId = "1234";
string userName = "******";
ClaimsPrincipal principle = new ClaimsPrincipal(new[]
{
new ClaimsIdentity(new [] { new Claim(ClaimTypes.Sid, userId), new Claim(ClaimTypes.Name, userName) })
});
HttpContext context = Substitute.For <HttpContext>();
context
.User
.Returns(principle);
HttpRequest request = Substitute.For <HttpRequest>();
request
.HttpContext
.Returns(context);
IMessengerService messengerService = CreateMessengerService();
PublishedResultsService resultsService = CreateResultsService(messengerService: messengerService);
//Act
IActionResult actionResult = await resultsService.ReIndexAllocationNotificationFeeds(request);
//Assert
actionResult
.Should()
.BeAssignableTo <NoContentResult>();
await
messengerService
.Received(1)
.SendToQueue(
Arg.Is(ServiceBusConstants.QueueNames.ReIndexAllocationNotificationFeedIndex),
Arg.Is(string.Empty),
Arg.Is <IDictionary <string, string> >(m => m["user-id"] == userId && m["user-name"] == userName));
}
public async Task GetPublishedProviderResultWithHistoryByAllocationResultId_GivenResultNotFound_ResturnsNull()
{
//Arrange
string allocationResultId = "12345";
IPublishedProviderResultsRepository publishedProviderResultsRepository = CreatePublishedProviderResultsRepository();
publishedProviderResultsRepository
.GetPublishedProviderResultForIdInPublishedState(Arg.Is(allocationResultId))
.Returns((PublishedProviderResult)null);
PublishedResultsService service = CreateResultsService(publishedProviderResultsRepository: publishedProviderResultsRepository);
//Act
PublishedProviderResultWithHistory result = await service.GetPublishedProviderResultWithHistoryByAllocationResultId(allocationResultId);
//Assert
result
.Should()
.BeNull();
}
public void GetPublishedProviderResultByVersionId_GivenVersionCannotBeFound_ReturnsNull()
{
//Arrange
string id = "id-1";
IPublishedProviderResultsRepository publishedProviderResultsRepository = CreatePublishedProviderResultsRepository();
publishedProviderResultsRepository
.GetPublishedProviderResultVersionForFeedIndexId(Arg.Is(id))
.Returns((PublishedAllocationLineResultVersion)null);
PublishedResultsService publishedResultsService = CreateResultsService(publishedProviderResultsRepository: publishedProviderResultsRepository);
//Act
PublishedProviderResult result = publishedResultsService.GetPublishedProviderResultByVersionId(id);
//Assert
result
.Should()
.BeNull();
}
public async Task CreateAllocationLineResultStatusUpdateJobs_GivenJobFoundButAlreadyCompleted_LogsAndReturnsDoesNotAddJobLog()
{
//Arrange
Message message = new Message();
message.UserProperties.Add("jobId", jobId);
ILogger logger = CreateLogger();
JobViewModel job = new JobViewModel
{
Id = jobId,
CompletionStatus = CompletionStatus.Cancelled
};
ApiResponse <JobViewModel> apiResponse = new ApiResponse <JobViewModel>(HttpStatusCode.OK, job);
IJobsApiClient jobsApiClient = CreateJobsApiClient();
jobsApiClient
.GetJobById(jobId)
.Returns(apiResponse);
PublishedResultsService publishedResultsService = CreateResultsService(logger, jobsApiClient: jobsApiClient);
//Act
await publishedResultsService.CreateAllocationLineResultStatusUpdateJobs(message);
//Assert
logger
.Received(1)
.Information(Arg.Is($"Received job with id: '{job.Id}' is already in a completed state with status {job.CompletionStatus.ToString()}"));
await
jobsApiClient
.DidNotReceive()
.AddJobLog(Arg.Any <string>(), Arg.Any <JobLogUpdateModel>());
}
public async Task GetPublishedProviderProfileForProviderIdAndSpecificationIdAndFundingStreamId_ValidData_ReturnsData()
{
string providerId = "123";
string specificationId = "456";
string fundingStreamId = "789";
IPublishedProviderResultsRepository publishedProviderResultsRepository = Substitute.For <IPublishedProviderResultsRepository>();
IEnumerable <PublishedProviderProfileViewModel> returnData = new[] { new PublishedProviderProfileViewModel() };
publishedProviderResultsRepository
.GetPublishedProviderProfileForProviderIdAndSpecificationIdAndFundingStreamId(providerId, specificationId, fundingStreamId)
.Returns(returnData);
PublishedResultsService service = CreateResultsService(publishedProviderResultsRepository: publishedProviderResultsRepository);
IActionResult result = await service.GetPublishedProviderProfileForProviderIdAndSpecificationIdAndFundingStreamId(providerId, specificationId, fundingStreamId);
await publishedProviderResultsRepository
.Received(1)
.GetPublishedProviderProfileForProviderIdAndSpecificationIdAndFundingStreamId(providerId, specificationId, fundingStreamId);
result.Should().BeOfType <OkObjectResult>();
(result as OkObjectResult).Value.Should().Be(returnData);
}
public async Task CreateAllocationLineResultStatusUpdateJobs_GivenNoJobId_LogsErrorAndDoesntFetchJob()
{
//Arrange
Message message = new Message();
ILogger logger = CreateLogger();
IJobsApiClient jobsApiClient = CreateJobsApiClient();
PublishedResultsService publishedResultsService = CreateResultsService(logger, jobsApiClient: jobsApiClient);
//Act
await publishedResultsService.CreateAllocationLineResultStatusUpdateJobs(message);
//Assert
logger
.Received(1)
.Error(Arg.Is("Missing parent job id to instruct allocation line status updates"));
await
jobsApiClient
.DidNotReceive()
.GetJobById(Arg.Any <string>());
}
public void GetPublishedProviderProfileForProviderIdAndSpecificationIdAndFundingStreamId_MissingData_LogsAndThrowsException(
string providerId,
string specificationId,
string fundingStreamId,
string parameterName,
string message)
{
//Arrange
ILogger logger = Substitute.For <ILogger>();
PublishedResultsService service = CreateResultsService(logger);
//Act
Func <Task> action = async() =>
await service.GetPublishedProviderProfileForProviderIdAndSpecificationIdAndFundingStreamId(providerId, specificationId, fundingStreamId);
//Assert
action
.Should().Throw <ArgumentNullException>()
.WithMessage($"{message}{Environment.NewLine}Parameter name: {parameterName}");
logger
.Received(1)
.Error(message);
}
public async Task GetPublishedProviderResultsBySpecificationId_GivenProviderResultsFound_ReturnsProviderResults()
{
//arrange
IQueryCollection queryStringValues = new QueryCollection(new Dictionary <string, StringValues>
{
{ "specificationId", new StringValues(specificationId) },
});
HttpRequest request = Substitute.For <HttpRequest>();
request
.Query
.Returns(queryStringValues);
IEnumerable <Models.Results.PublishedProviderResultByAllocationLineViewModel> publishedProviderResults = CreatePublishedProviderResultByAllocationLineViewModel();
IPublishedProviderResultsRepository publishedProviderResultsRepository = CreatePublishedProviderResultsRepository();
publishedProviderResultsRepository
.GetPublishedProviderResultSummaryForSpecificationId(Arg.Is(specificationId))
.Returns(publishedProviderResults);
PublishedResultsService resultsService = CreateResultsService(publishedProviderResultsRepository: publishedProviderResultsRepository);
//Act
IActionResult actionResult = await resultsService.GetPublishedProviderResultsBySpecificationId(request);
//Assert
actionResult
.Should()
.BeOfType <OkObjectResult>();
OkObjectResult okObjectResult = actionResult as OkObjectResult;
IEnumerable <PublishedProviderResultModel> publishedProviderResultModels = okObjectResult.Value as IEnumerable <PublishedProviderResultModel>;
publishedProviderResultModels
.Count()
.Should()
.Be(1);
publishedProviderResultModels
.First()
.ProviderName
.Should()
.Be("test provider name 1");
publishedProviderResultModels
.First()
.ProviderId
.Should()
.Be("1111");
publishedProviderResultModels
.First()
.FundingStreamResults
.Count()
.Should()
.Be(2);
publishedProviderResultModels
.First()
.FundingStreamResults
.First()
.AllocationLineResults
.Count()
.Should()
.Be(2);
publishedProviderResultModels
.First()
.FundingStreamResults
.Last()
.AllocationLineResults
.Count()
.Should()
.Be(1);
}
public async Task GetPublishedProviderResultsByFundingPeriodIdAndSpecificationIdAndFundingStreamId_GivenProviderResultsFound_ReturnsProviderResults()
{
//arrange
IQueryCollection queryStringValues = new QueryCollection(new Dictionary <string, StringValues>
{
{ "specificationId", new StringValues(specificationId) },
{ "fundingPeriodId", new StringValues(fundingPeriodId) },
{ "fundingStreamId", new StringValues(fundingStreamId) },
});
HttpRequest request = Substitute.For <HttpRequest>();
request
.Query
.Returns(queryStringValues);
IEnumerable <PublishedProviderResultByAllocationLineViewModel> publishedProviderResults = CreatePublishedProviderResultByAllocationLineViewModel();
IPublishedProviderResultsRepository publishedProviderResultsRepository = CreatePublishedProviderResultsRepository();
publishedProviderResultsRepository
.GetPublishedProviderResultsSummaryByFundingPeriodIdAndSpecificationIdAndFundingStreamId(Arg.Is(fundingPeriodId), Arg.Is(specificationId), Arg.Is(fundingStreamId))
.Returns(publishedProviderResults);
PublishedResultsService resultsService = CreateResultsService(publishedProviderResultsRepository: publishedProviderResultsRepository);
//Act
IActionResult actionResult = await resultsService.GetPublishedProviderResultsByFundingPeriodIdAndSpecificationIdAndFundingStreamId(request);
//Assert
OkObjectResult okObjectResult = actionResult
.Should()
.BeOfType <OkObjectResult>()
.Subject;
IEnumerable <PublishedProviderResultModel> publishedProviderResultModels = okObjectResult.Value
.Should()
.BeAssignableTo <IEnumerable <PublishedProviderResultModel> >()
.Subject;
publishedProviderResultModels
.Should()
.HaveCount(1, "there should be 1 results");
publishedProviderResultModels
.First()
.ProviderName
.Should()
.Be("test provider name 1");
publishedProviderResultModels
.First()
.ProviderId
.Should()
.Be("1111");
publishedProviderResultModels
.First()
.FundingStreamResults
.Should()
.HaveCount(2, "there should be 2 funding stream results");
publishedProviderResultModels
.First()
.FundingStreamResults
.First(f => f.FundingStreamId == "fs-1")
.AllocationLineResults
.Should()
.HaveCountLessOrEqualTo(2, "there should be 2 allocation line results for fs-1");
publishedProviderResultModels
.First()
.FundingStreamResults
.First(f => f.FundingStreamId == "fs-2")
.AllocationLineResults
.Should()
.HaveCountLessOrEqualTo(2, "there should be 1 allocation line results for fs-2");
}
public async Task UpdatePublishedAllocationLineResultsStatus_GivenBatchingButNoUpdateModel_ReturnsBadRequest()
{
//arrange
IQueryCollection queryStringValues = new QueryCollection(new Dictionary <string, StringValues>
{
{ "specificationId", new StringValues(specificationId) },
});
IEnumerable <UpdatePublishedAllocationLineResultStatusProviderModel> Providers = new[]
{
new UpdatePublishedAllocationLineResultStatusProviderModel
{
ProviderId = "1111",
AllocationLineIds = new[] { "AAAAA" }
},
new UpdatePublishedAllocationLineResultStatusProviderModel
{
ProviderId = "1111-1",
AllocationLineIds = new[] { "AAAAA" }
},
new UpdatePublishedAllocationLineResultStatusProviderModel
{
ProviderId = "1111-2",
AllocationLineIds = new[] { "AAAAA" }
}
};
UpdatePublishedAllocationLineResultStatusModel model = new UpdatePublishedAllocationLineResultStatusModel
{
Providers = Providers,
Status = AllocationLineStatus.Approved
};
string json = JsonConvert.SerializeObject(model);
byte[] byteArray = Encoding.UTF8.GetBytes(json);
MemoryStream stream = new MemoryStream(byteArray);
HttpRequest request = Substitute.For <HttpRequest>();
request
.Query
.Returns(queryStringValues);
request
.Body
.Returns(stream);
ILogger logger = CreateLogger();
Job newJob = new Job {
Id = "new-job-id"
};
IEnumerable <PublishedProviderResult> publishedProviderResults = CreatePublishedProviderResultsWithDifferentProviders();
foreach (PublishedProviderResult publishedProviderResult in publishedProviderResults)
{
publishedProviderResult.FundingStreamResult.AllocationLineResult.Current.ProfilingPeriods = new[] { new ProfilingPeriod() };
}
IJobsApiClient jobsApiClient = CreateJobsApiClient();
jobsApiClient
.CreateJob(Arg.Any <JobCreateModel>())
.Returns(newJob);
ICacheProvider cacheProvider = CreateCacheProvider();
PublishedResultsService resultsService = CreateResultsService(logger, jobsApiClient: jobsApiClient, cacheProvider: cacheProvider);
//Act
IActionResult actionResult = await resultsService.UpdatePublishedAllocationLineResultsStatus(request);
//Arrange
actionResult
.Should()
.BeAssignableTo <OkResult>();
logger
.Received(1)
.Information(Arg.Is($"New job: '{JobConstants.DefinitionNames.CreateInstructAllocationLineResultStatusUpdateJob}' created with id: '{newJob.Id}'"));
await
cacheProvider
.Received(1)
.SetAsync <UpdatePublishedAllocationLineResultStatusModel>(Arg.Any <string>(), Arg.Any <UpdatePublishedAllocationLineResultStatusModel>());
await
jobsApiClient
.Received(1)
.CreateJob(Arg.Is <JobCreateModel>(m =>
!string.IsNullOrWhiteSpace(m.InvokerUserDisplayName) &&
!string.IsNullOrWhiteSpace(m.InvokerUserId) &&
m.JobDefinitionId == JobConstants.DefinitionNames.CreateInstructAllocationLineResultStatusUpdateJob &&
m.SpecificationId == specificationId &&
m.Properties["specification-id"] == specificationId &&
!string.IsNullOrWhiteSpace(m.Properties["cache-key"]) &&
m.Trigger.EntityId == specificationId &&
m.Trigger.EntityType == "Specification" &&
m.Trigger.Message == $"Updating allocation line results status"
));
}
