public async Task UpdatePublishedRefreshedDate_WhenInvalidUpdateModel_ThenBadRequestReturned()
{
// Arrange
IQueryCollection queryStringValues = new QueryCollection(new Dictionary <string, StringValues>
{
{ "specificationId", new StringValues(SpecificationId) }
});
var wrongModel = new { PublishedResultsRefreshedAt = "wrong" }; // Wrong model
string json = JsonConvert.SerializeObject(wrongModel);
byte[] byteArray = Encoding.UTF8.GetBytes(json);
MemoryStream stream = new MemoryStream(byteArray);
HttpContext context = Substitute.For <HttpContext>();
SpecificationsService specsService = CreateService();
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 <BadRequestObjectResult>().Which.Value.Should().Be("An invalid refresh date was provided");
}
public async Task GetSpecificationsSelectedForFundingByPeriod_GivenSpecificationWasNotFound_ReturnsNotFound()
{
//Arrange
ILogger logger = CreateLogger();
ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository();
specificationsRepository
.GetSpecificationsByQuery(Arg.Any <Expression <Func <DocumentEntity <Specification>, bool> > >())
.Returns((Enumerable.Empty <Specification>()));
SpecificationsService service = CreateService(specificationsRepository: specificationsRepository, logs: logger);
//Act
IActionResult result = await service.GetSpecificationsSelectedForFundingByPeriod(FundingPeriodId);
//Assert
result
.Should()
.BeOfType <NotFoundResult>();
logger
.Received(1)
.Information(Arg.Is($"Specification was not found for funding period: {FundingPeriodId}"));
}
public async Task CheckCalculationProgressForSpecifications_WhenCacheisCorrupted_ReturnsBadRequestObjectResult()
{
//Arrange
IQueryCollection queryStringValues = new QueryCollection(new Dictionary <string, StringValues>
{
{ "specificationId", new StringValues(SpecificationId) },
});
HttpRequest request = Substitute.For <HttpRequest>();
request
.Query
.Returns(queryStringValues);
ICacheProvider cacheProvider = Substitute.For <ICacheProvider>();
cacheProvider.GetAsync <SpecificationCalculationExecutionStatus>($"{CacheKeys.CalculationProgress}{SpecificationId}").Returns <SpecificationCalculationExecutionStatus>(x => { throw new Exception(); });
ILogger logger = CreateLogger();
SpecificationsService service = CreateService(logs: logger, cacheProvider: cacheProvider);
//Act
IActionResult result = await service.CheckPublishResultStatus(request);
//Assert
result
.Should()
.BeOfType <InternalServerErrorResult>();
}
private SpecificationsService CreateSpecificationsService(Models.Specs.SpecificationVersion newSpecVersion)
{
_specificationsRepository
.GetSpecificationById(Arg.Is(SpecificationId))
.Returns(_specification);
_policiesApiClient
.GetFundingPeriodById(Arg.Is(_fundingPeriod.Id))
.Returns(_fundingPeriodResponse);
_specificationsRepository
.UpdateSpecification(Arg.Any <Specification>())
.Returns(HttpStatusCode.OK);
_versionRepository
.CreateVersion(Arg.Any <Models.Specs.SpecificationVersion>(), Arg.Any <Models.Specs.SpecificationVersion>())
.Returns(newSpecVersion);
SpecificationsService service = CreateService(
mapper: _mapper,
logs: _logger,
specificationsRepository: _specificationsRepository,
policiesApiClient: _policiesApiClient,
searchRepository: _searchRepository,
cacheProvider: _cacheProvider,
messengerService: _messengerService,
specificationVersionRepository: _versionRepository,
providersApiClient: _providersApiClient,
queueEditSpecificationJobActions: _editSpecificationJobActions);
return(service);
}
public async Task EditPolicy_GivenNoSpecificationIdWasProvided_ReturnsBadRequest()
{
//Arrange
HttpRequest request = Substitute.For <HttpRequest>();
ILogger logger = CreateLogger();
SpecificationsService service = CreateService(logs: logger);
//Act
IActionResult result = await service.EditPolicy(request);
//Arrange
result
.Should()
.BeOfType <BadRequestObjectResult>()
.Which
.Value
.Should()
.Be("Null or empty specification Id provided");
logger
.Received(1)
.Error(Arg.Is("No specification Id was provided to EditPolicy"));
}
public async Task GetCurrentSpecificationsByFundingPeriodIdAndFundingStreamId_GivenNoFundingStreamId_ReturnsBadRequestObject()
{
//Arrange
IQueryCollection queryStringValues = new QueryCollection(new Dictionary <string, StringValues>
{
{ "fundingPeriodId", new StringValues(FundingPeriodId) }
});
HttpRequest request = Substitute.For <HttpRequest>();
request
.Query
.Returns(queryStringValues);
ILogger logger = CreateLogger();
SpecificationsService service = CreateService(logs: logger);
//Act
IActionResult result = await service.GetCurrentSpecificationsByFundingPeriodIdAndFundingStreamId(request);
//Assert
result
.Should()
.BeOfType <BadRequestObjectResult>()
.Which
.Value
.Should()
.Be("Null or empty fundingstreamId provided");
logger
.Received(1)
.Error(Arg.Is("No funding stream Id was provided to GetSpecificationsByFundingPeriodIdAndFundingPeriodId"));
}
public void AssignDataDefinitionRelationship_GivenMessageWithObjectButDoesntValidate_ThrowsInvalidModelException()
{
//Arrange
dynamic anyObject = new { something = 1 };
string json = JsonConvert.SerializeObject(anyObject);
Message message = new Message(Encoding.UTF8.GetBytes(json));
ValidationResult validationResult = new ValidationResult(new[] {
new ValidationFailure("prop1", "any error")
});
IValidator <AssignDefinitionRelationshipMessage> validator = CreateAssignDefinitionRelationshipMessageValidator(validationResult);
SpecificationsService service = CreateService(assignDefinitionRelationshipMessageValidator: validator);
//Act
Func <Task> test = async() => await service.Process(message);
//Assert
test
.Should().ThrowExactly <InvalidModelException>();
}
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 GetCalculationByName_GivenModelDoesNotContainAcalculationName_ReturnsBadRequest()
{
//Arrange
CalculationGetModel model = new CalculationGetModel
{
SpecificationId = SpecificationId
};
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();
SpecificationsService service = CreateService(logs: logger);
//Act
IActionResult result = await service.GetCalculationByName(request);
//Assert
result
.Should()
.BeOfType <BadRequestObjectResult>();
logger
.Received(1)
.Error(Arg.Is("No calculation name was provided to GetCalculationByName"));
}
public async Task GetCalculationBySpecificationIdAndCalculationId_GivenCalculationIdDoesNotExist_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();
SpecificationsService service = CreateService(logs: logger);
//Act
IActionResult result = await service.GetCalculationBySpecificationIdAndCalculationId(request);
//Assert
result
.Should()
.BeOfType <BadRequestObjectResult>();
logger
.Received(1)
.Error(Arg.Is("No calculation Id was provided to GetCalculationBySpecificationIdAndCalculationId"));
}
public async Task SelectSpecificationForFunding_GivenNoSpecificationId_ReturnsBadRequestObject()
{
//Arrange
HttpRequest request = Substitute.For <HttpRequest>();
ILogger logger = CreateLogger();
SpecificationsService service = CreateService(logs: logger);
//Act
IActionResult result = await service.SelectSpecificationForFunding(request);
//Assert
result
.Should()
.BeOfType <BadRequestObjectResult>()
.Which
.Value
.Should()
.Be("Null or empty specification Id provided");
logger
.Received(1)
.Warning(Arg.Is("No specification Id was provided to SelectSpecificationForFunding"));
}
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_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 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 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 GetSpecificationByFundingPeriodId_GivenNoSpecificationsReturned_ReturnsSuccess()
{
//Arrange
IEnumerable <Specification> specs = Enumerable.Empty <Specification>();
ILogger logger = CreateLogger();
ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository();
specificationsRepository
.GetSpecificationsByQuery(Arg.Any <Expression <Func <DocumentEntity <Specification>, bool> > >())
.Returns(specs);
SpecificationsService service = CreateService(specificationsRepository: specificationsRepository, logs: logger);
//Act
IActionResult result = await service.GetSpecificationsByFundingPeriodId(FundingPeriodId);
//Assert
result
.Should()
.BeOfType <OkObjectResult>();
IEnumerable <SpecificationSummary> objContent = (IEnumerable <SpecificationSummary>)((OkObjectResult)result).Value;
objContent
.Count()
.Should()
.Be(0);
}
public ConsumerBackgroundService(Serilog.ILogger logger, CategorysService categoryService,
SpecificationsService specificationService,
SpecificationsGroupService specificationGroupService,
BrandsService brandsService,
ProductsService productService,
SKUService SKUService,
SpecificationValuesService specificationValuesService,
ProductSpecificationsService productSpecificationsService,
SKUSpecificationsService SKUSpecificationsService,
SKUFilesService SKUFilesService,
InventoryService inventoryService,
PricesService pricesService,
MotosService motosService,
FeedService feedService,
OrderService ordersService)
{
_logger = logger;
_categoryService = categoryService;
_specificationService = specificationService;
_specificationGroupService = specificationGroupService;
_brandsService = brandsService;
_productService = productService;
_SKUService = SKUService;
_specificationValuesService = specificationValuesService;
_productSpecificationsService = productSpecificationsService;
_SKUSpecificationsService = SKUSpecificationsService;
_SKUFilesService = SKUFilesService;
_inventoryService = inventoryService;
_pricesService = pricesService;
_motosService = motosService;
_feedService = feedService;
_ordersService = ordersService;
}
public async Task GetSpecificationByName_GivenSpecificationWasNotFound_ReturnsNotFoundt()
{
//Arrange
IEnumerable <Specification> specs = Enumerable.Empty <Specification>();
ILogger logger = CreateLogger();
ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository();
specificationsRepository
.GetSpecificationsByQuery(Arg.Any <Expression <Func <DocumentEntity <Specification>, bool> > >())
.Returns(specs);
SpecificationsService service = CreateService(specificationsRepository: specificationsRepository, logs: logger);
//Act
IActionResult result = await service.GetSpecificationByName(SpecificationName);
//Assert
result
.Should()
.BeOfType <NotFoundResult>();
logger
.Received(1)
.Information(Arg.Is($"Specification was not found for name: {SpecificationName}"));
}
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 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 async Task SpecificationsService_GetFundingStreamsForSpecificationById_WhenRequestingASpecificationWhenDoesNotExist_ThenErrorReturned()
{
// Arrange
const string specificationId = "spec1";
ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository();
SpecificationsService specificationsService = CreateService(specificationsRepository: specificationsRepository);
IQueryCollection queryStringValues = new QueryCollection(new Dictionary <string, StringValues>
{
{ "specificationId", new StringValues(specificationId) }
});
HttpRequest request = Substitute.For <HttpRequest>();
request
.Query
.Returns(queryStringValues);
// Act
IActionResult actionResult = await specificationsService.GetFundingStreamsForSpecificationById(request);
// Assert
List <FundingStream> expectedFundingStreams = new List <FundingStream>();
actionResult
.Should()
.BeOfType <PreconditionFailedResult>()
.Which
.Value
.Should()
.Be("Specification not found");
}
public async Task GetSpecificationsSelectedForFundingByPeriod_GivenSpecificationWasFound_ReturnsSpecification()
{
//Arrange
SpecificationVersion sv1 = new SpecificationVersion {
SpecificationId = "spec1", FundingPeriod = new Reference {
Id = "18/19", Name = "18/19"
}
};
SpecificationVersion sv2 = new SpecificationVersion {
SpecificationId = "spec2", FundingPeriod = new Reference {
Id = "17/18", Name = "17/18"
}
};
Specification spec1 = new Specification {
Id = "spec1", IsSelectedForFunding = true, Current = sv1
};
Specification spec2 = new Specification {
Id = "spec2", IsSelectedForFunding = true, Current = sv2
};
IQueryCollection queryStringValues = new QueryCollection(new Dictionary <string, StringValues>
{
{ "fundingPeriodId", new StringValues(FundingPeriodId) }
});
HttpRequest request = Substitute.For <HttpRequest>();
request
.Query
.Returns(queryStringValues);
ILogger logger = CreateLogger();
ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository();
specificationsRepository
.GetSpecificationsByQuery(Arg.Any <Expression <Func <Specification, bool> > >())
.Returns(new[] { spec1 });
SpecificationsService service = CreateService(specificationsRepository: specificationsRepository, logs: logger);
//Act
IActionResult result = await service.GetSpecificationsSelectedForFundingByPeriod(request);
//Assert
result
.Should()
.BeOfType <OkObjectResult>();
OkObjectResult okObjectResult = result as OkObjectResult;
IEnumerable <SpecificationSummary> summaries = okObjectResult.Value as IEnumerable <SpecificationSummary>;
summaries
.Count()
.Should()
.Be(1);
}
public async Task SpecificationsService_GetFundingStreamsForSpecificationById_WhenHasMissingSpecificationId_ThenErrorReturned()
{
// Arrange
ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository();
SpecificationsService specificationsService = CreateService(specificationsRepository: specificationsRepository);
IQueryCollection queryStringValues = new QueryCollection(new Dictionary <string, StringValues>
{
{ "specificationId", new StringValues(string.Empty) }
});
HttpRequest request = Substitute.For <HttpRequest>();
request
.Query
.Returns(queryStringValues);
// Act
IActionResult actionResult = await specificationsService.GetFundingStreamsForSpecificationById(request);
// Assert
List <FundingStream> expectedFundingStreams = new List <FundingStream>();
actionResult
.Should()
.BeOfType <BadRequestObjectResult>()
.Which
.Value
.Should()
.Be("Null or empty specificationId provided");
}
public async Task EditPolicy_GivenNullEditModeldWasProvided_ReturnsBadRequest()
{
//Arrange
IQueryCollection queryStringValues = new QueryCollection(new Dictionary <string, StringValues>
{
{ "specificationId", new StringValues(SpecificationId) },
{ "policyId", new StringValues(PolicyId) }
});
HttpRequest request = Substitute.For <HttpRequest>();
request
.Query
.Returns(queryStringValues);
ILogger logger = CreateLogger();
SpecificationsService service = CreateService(logs: logger);
//Act
IActionResult result = await service.EditPolicy(request);
//Arrange
result
.Should()
.BeOfType <BadRequestObjectResult>()
.Which
.Value
.Should()
.Be("Null policy edit model provided");
logger
.Received(1)
.Error(Arg.Is("Null edit modeld was provided to EditPolicy"));
}
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 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 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 CheckCalculationProgressForSpecifications_WhenTheHttpRequestQueryIsNull_ReturnsBadRequestObjectResult()
{
//Arrange
HttpRequest request = Substitute.For <HttpRequest>();
request.Query.Returns(x => null);
ILogger logger = CreateLogger();
SpecificationsService service = CreateService(logs: logger);
//Act
IActionResult result = await service.CheckPublishResultStatus(request);
//Assert
result
.Should()
.BeOfType <BadRequestObjectResult>()
.Which
.Value
.Should()
.Be("the request query is empty or null");
logger
.Received(1)
.Error(Arg.Is("The http request query is empty or null"));
}
public async Task GetSpecificationsWithProviderVersionUpdatesAsUseLatest_GivenSpecificationWasNotFound_ReturnsNotFound()
{
//Arrange
ILogger logger = CreateLogger();
ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository();
specificationsRepository
.GetSpecificationsByQuery(Arg.Any <Expression <Func <DocumentEntity <Specification>, bool> > >())
.Returns((Enumerable.Empty <Specification>()));
SpecificationsService service = CreateService(specificationsRepository: specificationsRepository, logs: logger);
//Act
IActionResult result = await service.GetSpecificationsWithProviderVersionUpdatesAsUseLatest();
//Assert
result
.Should()
.BeOfType <NotFoundResult>();
logger
.Received(1)
.Information(Arg.Is($"Specifications was not found with CoreProviderVersionUpdates as UseLatest"));
}
