public TestEngineService(
ICacheProvider cacheProvider,
ISpecificationRepository specificationRepository,
ILogger logger,
ITestEngine testEngine,
IScenariosRepository scenariosRepository,
IProviderSourceDatasetsRepository providerSourceDatasetsRepository,
ITestResultsService testResultsService,
ITestResultsRepository testResultsRepository,
IBuildProjectRepository buildProjectRepository,
ITelemetry telemetry,
ITestRunnerResiliencePolicies resiliencePolicies,
ICalculationsRepository calculationsRepository)
{
_cacheProvider = cacheProvider;
_specificationRepository = specificationRepository;
_logger = logger;
_testEngine = testEngine;
_scenariosRepository = scenariosRepository;
_providerSourceDatasetsRepository = providerSourceDatasetsRepository;
_testResultsService = testResultsService;
_testResultsRepository = testResultsRepository;
_telemetry = telemetry;
_cacheProviderPolicy = resiliencePolicies.CacheProviderRepository;
_specificationRepositoryPolicy = resiliencePolicies.SpecificationRepository;
_scenariosRepositoryPolicy = resiliencePolicies.ScenariosRepository;
_providerSourceDatasetsRepositoryPolicy = resiliencePolicies.ProviderSourceDatasetsRepository;
_testResultsRepositoryPolicy = resiliencePolicies.TestResultsRepository;
_builProjectsRepositoryPolicy = resiliencePolicies.BuildProjectRepository;
_buildProjectRepository = buildProjectRepository;
_calculationsRepository = calculationsRepository;
}
public async Task IsCalculationNameValid_WhenCalculationDoesNotExist_ThenReturnsOkResult()
{
// Arrange
string specificationId = "spec1";
ISpecificationRepository specificationRepository = CreateSpecificationRepository();
specificationRepository
.GetSpecificationSummaryById(Arg.Is(specificationId))
.Returns(new SpecificationSummary {
Id = specificationId
});
ICalculationsRepository calculationsRepository = CreateCalculationsRepository();
calculationsRepository
.GetCalculationsBySpecificationId(Arg.Is(specificationId))
.Returns(new List <Models.Calcs.Calculation>());
CalculationService service = CreateCalculationService(specificationRepository: specificationRepository, calculationsRepository: calculationsRepository);
// Act
IActionResult result = await service.IsCalculationNameValid(specificationId, "calc1", null);
// Assert
result
.Should()
.BeOfType <OkResult>();
}
public DeprecateDataEntryHandler(IVmsLogger <DeprecateDataEntryHandler> logger, IServiceBusMessagePublisher publisher, ISpecificationRepository repository, ISpecificationAggregate specificationAggregate)
{
_logger = logger;
_publisher = publisher;
_repository = repository;
_specificationAggregate = specificationAggregate;
}
public FundingStreamPermissionService(
IUserRepository userRepository,
ISpecificationRepository specificationRepository,
IVersionRepository <FundingStreamPermissionVersion> fundingStreamPermissionVersionRepository,
ICacheProvider cacheProvider,
IMapper mapper,
ILogger logger,
IUsersResiliencePolicies policies)
{
Guard.ArgumentNotNull(userRepository, nameof(userRepository));
Guard.ArgumentNotNull(specificationRepository, nameof(specificationRepository));
Guard.ArgumentNotNull(fundingStreamPermissionVersionRepository, nameof(fundingStreamPermissionVersionRepository));
Guard.ArgumentNotNull(cacheProvider, nameof(cacheProvider));
Guard.ArgumentNotNull(mapper, nameof(mapper));
Guard.ArgumentNotNull(logger, nameof(logger));
Guard.ArgumentNotNull(policies, nameof(policies));
_userRepository = userRepository;
_specificationsRepository = specificationRepository;
_fundingStreamPermissionVersionRepository = fundingStreamPermissionVersionRepository;
_cacheProvider = cacheProvider;
_mapper = mapper;
_logger = logger;
_userRepositoryPolicy = policies.UserRepositoryPolicy;
_specificationsRepositoryPolicy = policies.SpecificationRepositoryPolicy;
_fundingStreamPermissionVersionRepositoryPolicy = policies.FundingStreamPermissionVersionRepositoryPolicy;
_cacheProviderPolicy = policies.CacheProviderPolicy;
}
private static CalculationService CreateCalculationService(
ICalculationsRepository calculationsRepository = null,
ILogger logger = null,
ISearchRepository <CalculationIndex> searchRepository = null,
IValidator <Calculation> calcValidator = null,
IBuildProjectsService buildProjectsService = null,
ISpecificationRepository specificationRepository = null,
ICacheProvider cacheProvider = null,
ICalcsResiliencePolicies resiliencePolicies = null,
IVersionRepository <CalculationVersion> calculationVersionRepository = null,
IJobsApiClient jobsApiClient = null,
ISourceCodeService sourceCodeService = null,
IFeatureToggle featureToggle = null,
IBuildProjectsRepository buildProjectsRepository = null,
ICalculationCodeReferenceUpdate calculationCodeReferenceUpdate = null)
{
return(new CalculationService
(calculationsRepository ?? CreateCalculationsRepository(),
logger ?? CreateLogger(),
searchRepository ?? CreateSearchRepository(),
calcValidator ?? CreateCalculationValidator(),
buildProjectsService ?? CreateBuildProjectsService(),
specificationRepository ?? CreateSpecificationRepository(),
cacheProvider ?? CreateCacheProvider(),
resiliencePolicies ?? CalcsResilienceTestHelper.GenerateTestPolicies(),
calculationVersionRepository ?? CreateCalculationVersionRepository(),
jobsApiClient ?? CreateJobsApiClient(),
sourceCodeService ?? CreateSourceCodeService(),
featureToggle ?? CreateFeatureToggle(),
buildProjectsRepository ?? CreateBuildProjectsRepository(),
calculationCodeReferenceUpdate ?? CreateCalculationCodeReferenceUpdate()));
}
public UpdateEntryOrderHandler(IVmsLogger <UpdateEntryOrderHandler> logger, IServiceBusMessagePublisher publisher, ISpecificationRepository repository, ISpecificationAggregate specificationAggregate)
{
_logger = logger;
_publisher = publisher;
_repository = repository;
_specificationAggregate = specificationAggregate;
}
public CreateDataEntryHandler(IVmsLogger <CreateDataEntryHandler> logger, IServiceBusMessagePublisher publisher, ISpecificationAggregate aggregate, ISpecificationRepository repository)
{
_logger = logger;
_publisher = publisher;
_aggregate = aggregate;
_repository = repository;
}
/// <summary>
/// Loads the data
/// </summary>
/// <returns></returns>
public override async Task LoadDataGridData()
{
_specRepo = new SpecificationRepository();
// Gets all the specifications, and maps it to objects fit to display in the datagrid
SpecList = new ObservableCollection <SpecificationOverviewItem>
(EntitiesMapping.MapToSpecificationOverviewItem(await _specRepo.GetAllAsync(), _preferredLanguage.ID)
.OrderBy(x => x.SpecName).ToList());
BindData();
}
public void CreateCalculation_CreatingCalculationButAssociatedCalculationSpecificationNotFound_ThrowsException()
{
//Arrange
Calculation calculation = CreateCalculation();
IEnumerable <Calculation> calculations = new[]
{
calculation
};
string json = JsonConvert.SerializeObject(calculation);
IEnumerable <Models.Specs.Calculation> calculationSpecifications = new[]
{
new Models.Specs.Calculation
{
Id = "any-id"
}
};
Message message = new Message(Encoding.UTF8.GetBytes(json));
message.UserProperties.Add("user-id", UserId);
message.UserProperties.Add("user-name", Username);
ILogger logger = CreateLogger();
ISearchRepository <CalculationIndex> searchRepository = CreateSearchRepository();
Models.Specs.SpecificationSummary specificationSummary = new Models.Specs.SpecificationSummary()
{
Id = calculation.SpecificationId,
Name = "Test Spec Name",
};
ISpecificationRepository specificationRepository = CreateSpecificationRepository();
specificationRepository
.GetSpecificationSummaryById(Arg.Is(calculation.SpecificationId))
.Returns(specificationSummary);
specificationRepository
.GetCalculationSpecificationsForSpecification(Arg.Is(calculation.SpecificationId))
.Returns(calculationSpecifications);
CalculationService service = CreateCalculationService(logger: logger, searchRepository: searchRepository, specificationRepository: specificationRepository);
//Act
Func <Task> test = async() => await service.CreateCalculation(message);
//Assert
test
.Should().ThrowExactly <RetriableException>()
.WithMessage($"A calculation specification was not found for calculation specification id '{calculation.CalculationSpecification.Id}'");
}
public static IQueryable <TEntity> GetQuery(IQueryable <TEntity> inputQuery
, ISpecificationRepository <TEntity> specification)
{
var query = inputQuery;
if (specification.criteria != null)
{
query = query.Where(specification.criteria);
}
query = specification.Includes.Aggregate(query, (current, include) => current.Include(include));
return(query);
}
public void SetupTest()
{
_logger = Substitute.For <ILogger>();
_calculationRepository = Substitute.For <ICalculationRepository>();
_specificationRepository = Substitute.For <ISpecificationRepository>();
_datasetRepository = Substitute.For <IDatasetRepository>();
_fundingLineRepository = Substitute.For <IFundingLineRepository>();
_graphService = new GraphService(_logger,
_calculationRepository,
_specificationRepository,
_datasetRepository,
_fundingLineRepository);
}
public async Task GetEffectivePermissionsForUser_WhenNotFoundInCacheButSpecificationNotFound_ThenPreconditionFailedResultReturned()
{
// Arrange
ICacheProvider cacheProvider = CreateCacheProvider();
EffectiveSpecificationPermission cachedPermission = null;
cacheProvider
.GetHashValue <EffectiveSpecificationPermission>(Arg.Is($"{CacheKeys.EffectivePermissions}:{UserId}"), Arg.Is(SpecificationId))
.Returns(cachedPermission);
ISpecificationRepository specificationRepository = CreateSpecificationRepository();
SpecificationSummary specificationSummary = null;
specificationRepository
.GetSpecificationSummaryById(Arg.Is(SpecificationId))
.Returns(specificationSummary);
FundingStreamPermissionService service = CreateService(
specificationRepository: specificationRepository,
cacheProvider: cacheProvider);
// Act
IActionResult result = await service.GetEffectivePermissionsForUser(UserId, SpecificationId, null);
// Assert
result
.Should()
.BeOfType <PreconditionFailedResult>()
.Which
.Value
.Should()
.Be("Specification not found");
await cacheProvider
.Received(1)
.GetHashValue <EffectiveSpecificationPermission>(Arg.Is($"{CacheKeys.EffectivePermissions}:{UserId}"), Arg.Is(SpecificationId));
await cacheProvider
.Received(0)
.SetHashValue(
Arg.Is($"{CacheKeys.EffectivePermissions}:{UserId}"),
Arg.Is(SpecificationId),
Arg.Any <EffectiveSpecificationPermission>());
}
public BuildProjectsService(
ILogger logger,
ITelemetry telemetry,
IProviderResultsRepository providerResultsRepository,
ISpecificationRepository specificationsRepository,
ICacheProvider cacheProvider,
ICalculationsRepository calculationsRepository,
IFeatureToggle featureToggle,
IJobsApiClient jobsApiClient,
ICalcsResiliencePolicies resiliencePolicies,
EngineSettings engineSettings,
ISourceCodeService sourceCodeService,
IDatasetRepository datasetRepository,
IBuildProjectsRepository buildProjectsRepository)
{
Guard.ArgumentNotNull(logger, nameof(logger));
Guard.ArgumentNotNull(telemetry, nameof(telemetry));
Guard.ArgumentNotNull(providerResultsRepository, nameof(providerResultsRepository));
Guard.ArgumentNotNull(specificationsRepository, nameof(specificationsRepository));
Guard.ArgumentNotNull(cacheProvider, nameof(cacheProvider));
Guard.ArgumentNotNull(calculationsRepository, nameof(calculationsRepository));
Guard.ArgumentNotNull(featureToggle, nameof(featureToggle));
Guard.ArgumentNotNull(jobsApiClient, nameof(jobsApiClient));
Guard.ArgumentNotNull(resiliencePolicies, nameof(resiliencePolicies));
Guard.ArgumentNotNull(engineSettings, nameof(engineSettings));
Guard.ArgumentNotNull(sourceCodeService, nameof(sourceCodeService));
Guard.ArgumentNotNull(datasetRepository, nameof(datasetRepository));
Guard.ArgumentNotNull(buildProjectsRepository, nameof(buildProjectsRepository));
_logger = logger;
_telemetry = telemetry;
_providerResultsRepository = providerResultsRepository;
_specificationsRepository = specificationsRepository;
_cacheProvider = cacheProvider;
_calculationsRepository = calculationsRepository;
_featureToggle = featureToggle;
_jobsApiClient = jobsApiClient;
_jobsApiClientPolicy = resiliencePolicies.JobsApiClient;
_engineSettings = engineSettings;
_sourceCodeService = sourceCodeService;
_datasetRepository = datasetRepository;
_datasetRepositoryPolicy = resiliencePolicies.DatasetsRepository;
_buildProjectsRepository = buildProjectsRepository;
_buildProjectsRepositoryPolicy = resiliencePolicies.BuildProjectRepositoryPolicy;
}
public SpecificationForm(int ID)
{
InitializeComponent();
// Defines the progressbar and submit button to allow the progressbar methods to work in the FormUserControl(base)
progressBar = prog;
submitButton = btnSubmit;
_specRepo = new SpecificationRepository();
SpecModel = _specRepo.Get(ID);
_updatingPage = !SpecModel.IsNew();
PrepareUpdate();
DataContext = this;
}
public GraphService(ILogger logger,
ICalculationRepository calcRepository,
ISpecificationRepository specRepository,
IDatasetRepository datasetRepository,
IFundingLineRepository fundingLineRepository)
{
Guard.ArgumentNotNull(logger, nameof(logger));
Guard.ArgumentNotNull(calcRepository, nameof(calcRepository));
Guard.ArgumentNotNull(specRepository, nameof(specRepository));
Guard.ArgumentNotNull(datasetRepository, nameof(datasetRepository));
Guard.ArgumentNotNull(fundingLineRepository, nameof(fundingLineRepository));
_logger = logger;
_calcRepository = calcRepository;
_specRepository = specRepository;
_datasetRepository = datasetRepository;
_fundingLineRepository = fundingLineRepository;
}
public async Task IsCalculationNameValid_WhenSameCalculation_ThenReturnsOkResult()
{
// Arrange
string specificationId = "spec1";
string calcName = "calc1";
string calcSpecId = "calc-spec-id-1";
ISpecificationRepository specificationRepository = CreateSpecificationRepository();
specificationRepository
.GetSpecificationSummaryById(Arg.Is(specificationId))
.Returns(new SpecificationSummary {
Id = specificationId
});
List <Models.Calcs.Calculation> existingCalcs = new List <Models.Calcs.Calculation>
{
new Models.Calcs.Calculation
{
Name = calcName,
SourceCodeName = calcName,
Id = "calc-1",
CalculationSpecification = new Common.Models.Reference {
Id = calcSpecId
}
}
};
ICalculationsRepository calculationsRepository = CreateCalculationsRepository();
calculationsRepository
.GetCalculationsBySpecificationId(Arg.Is(specificationId))
.Returns(existingCalcs);
CalculationService service = CreateCalculationService(specificationRepository: specificationRepository, calculationsRepository: calculationsRepository);
// Act
IActionResult result = await service.IsCalculationNameValid(specificationId, calcName, calcSpecId);
// Assert
result
.Should()
.BeOfType <OkResult>();
}
/// <summary>
/// Functionality that has to happen in both the create and update form
/// </summary>
private void InitializeWindow()
{
// Defines the progressBar and SubmitButton to allow the ProgressBar methods to work (see FormUserControl)
progressBar = prog;
submitButton = btnSubmit;
_langRepo = new LanguageRepository();
_specRepo = new SpecificationRepository();
// Sets display language
_preferredLanguage = Properties.Settings.Default.CurrentUser.PreferredLanguage;
SetLanguageDictionary();
DataContext = this;
_updatingPage = !CategoryModel.IsNew();
SetTitle();
}
public FundingStreamPermissionService CreateService(
IUserRepository userRepository = null,
ISpecificationRepository specificationRepository = null,
IVersionRepository <FundingStreamPermissionVersion> fundingStreamPermissionVersionRepository = null,
ICacheProvider cacheProvider = null,
IMapper mapper = null,
ILogger logger = null,
IUsersResiliencePolicies policies = null)
{
return(new FundingStreamPermissionService(
userRepository ?? CreateUserRepository(),
specificationRepository ?? CreateSpecificationRepository(),
fundingStreamPermissionVersionRepository ?? CreateFundingStreamPermissionRepository(),
cacheProvider ?? CreateCacheProvider(),
mapper ?? CreateMappingConfiguration(),
logger ?? CreateLogger(),
policies ?? CreatePoliciesNoOp()
));
}
public AdminController(IBikeRepository bikeRepository,
ILogger <AdminController> logger,
IRepo <Size> sizeRepository,
IRepo <Color> colorRepository,
ICategoryRepository categoryRepository,
ISpecificationRepository specificaionRepository,
IRepo <SpecificationCategory> specificationCategoryRepository,
IRepo <ImgContent> imgRepo,
IMapper mapper)
{
_bikeRepo = bikeRepository ?? throw new ArgumentNullException(nameof(bikeRepository));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_colorRepo = colorRepository ?? throw new ArgumentNullException(nameof(colorRepository));
_sizeRepo = sizeRepository ?? throw new ArgumentNullException(nameof(sizeRepository));
_categoryRepo = categoryRepository ?? throw new ArgumentNullException(nameof(categoryRepository));
_specificaionRepo = specificaionRepository ?? throw new ArgumentNullException(nameof(specificaionRepository));
_specificationCategoryRepo = specificationCategoryRepository ?? throw new ArgumentNullException(nameof(specificationCategoryRepository));
_mapper = mapper ?? throw new ArgumentNullException(nameof(mapper));
_imgRepo = imgRepo ?? throw new ArgumentNullException(nameof(imgRepo));
}
public async Task IsCalculationNameValid_WhenSpecificationDoesNotExist_ThenReturnsNotFoundResult()
{
// Arrange
string specificationId = "spec1";
ISpecificationRepository specificationRepository = CreateSpecificationRepository();
specificationRepository
.GetSpecificationSummaryById(Arg.Is(specificationId))
.Returns((SpecificationSummary)null);
CalculationService service = CreateCalculationService(specificationRepository: specificationRepository);
// Act
IActionResult result = await service.IsCalculationNameValid(specificationId, "calc1", null);
// Assert
result
.Should()
.BeOfType <NotFoundResult>();
}
public SpecificationForm()
{
InitializeComponent();
// Defines the progressbar and submit button to allow the progressbar methods to work in the FormUserControl(base)
progressBar = prog;
submitButton = btnSubmit;
SpecModel = new Specification()
{
LocalizedSpecifications = new List <LocalizedSpecification>()
};
_specRepo = new SpecificationRepository();
InitializeCreateForm();
// Model binding is not always working for checkboxes, so I'm checking these in code.
cbIsBool.IsChecked = true;
DataContext = this;
}
public async Task EditCalculationStatus_GivenNewStatusOfUpdated_UpdatesSearchReturnsOK()
{
//Arrange
EditStatusModel CalculationEditStatusModel = new EditStatusModel
{
PublishStatus = PublishStatus.Updated
};
string json = JsonConvert.SerializeObject(CalculationEditStatusModel);
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>
{
{ "calculationId", new StringValues(CalculationId) },
});
request
.Query
.Returns(queryStringValues);
request
.Body
.Returns(stream);
request
.HttpContext
.Returns(context);
ILogger logger = CreateLogger();
Calculation calculation = CreateCalculation();
calculation.Current.PublishStatus = PublishStatus.Approved;
CalculationVersion calculationVersion = calculation.Current.Clone() as CalculationVersion;
calculationVersion.PublishStatus = PublishStatus.Updated;
ICalculationsRepository CalculationsRepository = CreateCalculationsRepository();
CalculationsRepository
.GetCalculationById(Arg.Is(CalculationId))
.Returns(calculation);
CalculationsRepository
.UpdateCalculation(Arg.Any <Calculation>())
.Returns(HttpStatusCode.OK);
ISearchRepository <CalculationIndex> searchRepository = CreateSearchRepository();
Models.Specs.SpecificationSummary specificationSummary = new Models.Specs.SpecificationSummary();
ISpecificationRepository specificationRepository = CreateSpecificationRepository();
specificationRepository
.GetSpecificationSummaryById(Arg.Is(calculation.SpecificationId))
.Returns(specificationSummary);
IVersionRepository <CalculationVersion> versionRepository = CreateCalculationVersionRepository();
versionRepository
.CreateVersion(Arg.Any <CalculationVersion>(), Arg.Any <CalculationVersion>())
.Returns(calculationVersion);
Build build = new Build
{
SourceFiles = new List <SourceFile> {
new SourceFile()
}
};
BuildProject buildProject = new BuildProject();
IBuildProjectsService buildProjectsService = CreateBuildProjectsService();
buildProjectsService
.GetBuildProjectForSpecificationId(Arg.Is(calculation.SpecificationId))
.Returns(buildProject);
ISourceCodeService sourceCodeService = CreateSourceCodeService();
sourceCodeService
.Compile(Arg.Any <BuildProject>(), Arg.Any <IEnumerable <Models.Calcs.Calculation> >(), Arg.Any <CompilerOptions>())
.Returns(build);
CalculationService service = CreateCalculationService(
logger: logger, calculationsRepository: CalculationsRepository, searchRepository: searchRepository,
specificationRepository: specificationRepository, calculationVersionRepository: versionRepository,
sourceCodeService: sourceCodeService, buildProjectsService: buildProjectsService);
//Act
IActionResult result = await service.UpdateCalculationStatus(request);
//Arrange
result
.Should()
.BeOfType <OkObjectResult>()
.Which
.Value
.Should()
.BeOfType <PublishStatusResultModel>()
.Which
.PublishStatus
.Should()
.Be(PublishStatus.Updated);
calculation
.Current
.PublishStatus
.Should()
.Be(PublishStatus.Updated);
await
searchRepository
.Received(1)
.Index(Arg.Is <IEnumerable <CalculationIndex> >(m => m.First().Status == "Updated"));
}
public async Task EditCalculationStatus_GivenCalculationIsApprovedButNewStatusIsDraft_UpdatesSearchReturnsOK()
{
//Arrange
EditStatusModel CalculationEditStatusModel = new EditStatusModel
{
PublishStatus = PublishStatus.Draft
};
string json = JsonConvert.SerializeObject(CalculationEditStatusModel);
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>
{
{ "calculationId", new StringValues(CalculationId) },
});
request
.Query
.Returns(queryStringValues);
request
.Body
.Returns(stream);
request
.HttpContext
.Returns(context);
ILogger logger = CreateLogger();
Calculation calculation = CreateCalculation();
calculation.Current.PublishStatus = PublishStatus.Approved;
ICalculationsRepository CalculationsRepository = CreateCalculationsRepository();
CalculationsRepository
.GetCalculationById(Arg.Is(CalculationId))
.Returns(calculation);
CalculationsRepository
.UpdateCalculation(Arg.Any <Calculation>())
.Returns(HttpStatusCode.OK);
Models.Specs.SpecificationSummary specificationSummary = new Models.Specs.SpecificationSummary();
ISpecificationRepository specificationRepository = CreateSpecificationRepository();
specificationRepository
.GetSpecificationSummaryById(Arg.Is(calculation.SpecificationId))
.Returns(specificationSummary);
ISearchRepository <CalculationIndex> searchRepository = CreateSearchRepository();
CalculationService service = CreateCalculationService(
logger: logger, calculationsRepository: CalculationsRepository, searchRepository: searchRepository, specificationRepository: specificationRepository);
//Act
IActionResult result = await service.UpdateCalculationStatus(request);
//Arrange
result
.Should()
.BeOfType <BadRequestObjectResult>()
.Which
.Value
.Should()
.Be("Publish status can't be changed to Draft from Updated or Approved");
calculation
.Current
.PublishStatus
.Should()
.Be(PublishStatus.Approved);
await
searchRepository
.Received(0)
.Index(Arg.Any <IEnumerable <CalculationIndex> >());
}
public async Task EditCalculationStatus_GivenNewStatusButUpdatingDbReturnsBadRequest_ReturnsStatusCode400()
{
//Arrange
EditStatusModel CalculationEditStatusModel = new EditStatusModel
{
PublishStatus = PublishStatus.Approved
};
string json = JsonConvert.SerializeObject(CalculationEditStatusModel);
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>
{
{ "calculationId", new StringValues(CalculationId) },
});
request
.Query
.Returns(queryStringValues);
request
.Body
.Returns(stream);
request
.HttpContext
.Returns(context);
ILogger logger = CreateLogger();
Calculation calculation = CreateCalculation();
ICalculationsRepository CalculationsRepository = CreateCalculationsRepository();
CalculationsRepository
.GetCalculationById(Arg.Is(CalculationId))
.Returns(calculation);
CalculationsRepository
.UpdateCalculation(Arg.Any <Calculation>())
.Returns(HttpStatusCode.BadRequest);
Models.Specs.SpecificationSummary specificationSummary = new Models.Specs.SpecificationSummary();
ISpecificationRepository specificationRepository = CreateSpecificationRepository();
specificationRepository
.GetSpecificationSummaryById(Arg.Is(calculation.SpecificationId))
.Returns(specificationSummary);
CalculationService service = CreateCalculationService(
logger: logger, calculationsRepository: CalculationsRepository, specificationRepository: specificationRepository);
//Act
IActionResult result = await service.UpdateCalculationStatus(request);
//Arrange
result
.Should()
.BeAssignableTo <StatusCodeResult>()
.Which
.StatusCode
.Should()
.Be(400);
}
public SpecificationBehavior(ISpecificationRepository repository)
{
_repository = repository;
}
public CreateSpecificationCommandHandler(ISpecificationRepository specificationRepository)
{
_specificationRepository = specificationRepository;
}
public SpecificationComponent(ISpecificationRepository specificationRepository)
{
_specificationRepository = specificationRepository;
}
public async Task ResetCalculationForFieldDefinitionChanges_GivenCalculationRequiresReset_UpdatesCalculationsAndDeletesAssembly()
{
//Arrange
const string specificationId = "spec-id";
IEnumerable <DatasetSpecificationRelationshipViewModel> relationships = new[]
{
new DatasetSpecificationRelationshipViewModel
{
Name = "Test Name"
}
};
IEnumerable <string> currentFieldDefinitionNames = new[]
{
"Test Field"
};
ILogger logger = CreateLogger();
CalculationVersion calculationVersion = new CalculationVersion
{
SourceCode = "return Datasets.TestName.TestField",
Date = DateTimeOffset.Now
};
IEnumerable <Calculation> calculations = new[]
{
new Calculation
{
Current = calculationVersion,
SpecificationId = specificationId,
CalculationSpecification = new Reference("calc-spac-id", "calc spec name"),
FundingPeriod = new Reference("fp1", "fp 1"),
FundingStream = new Reference("fs1", "fs 1"),
Policies = new List <Reference> {
new Reference {
Id = "policy-1", Name = "policy 1"
}
}
}
};
IEnumerable <Models.Specs.Calculation> calculationSpecifications = new[]
{
new Models.Specs.Calculation
{
Id = "calc-spec-id"
}
};
BuildProject buildProject = new BuildProject();
Build build = new Build
{
SourceFiles = new List <SourceFile>()
};
Models.Specs.SpecificationSummary specificationSummary = new Models.Specs.SpecificationSummary();
ICalculationsRepository calculationsRepository = CreateCalculationsRepository();
calculationsRepository
.GetCalculationsBySpecificationId(Arg.Is(specificationId))
.Returns(calculations);
calculationsRepository
.UpdateCalculation(Arg.Any <Calculation>())
.Returns(HttpStatusCode.OK);
ISpecificationRepository specificationRepository = CreateSpecificationRepository();
specificationRepository
.GetCalculationSpecificationsForSpecification(Arg.Is(specificationId))
.Returns(calculationSpecifications);
specificationRepository
.GetSpecificationSummaryById(Arg.Is(specificationId))
.Returns(specificationSummary);
IBuildProjectsService buildProjectsService = CreateBuildProjectsService();
buildProjectsService
.GetBuildProjectForSpecificationId(Arg.Is(specificationId))
.Returns(buildProject);
ISourceCodeService sourceCodeService = CreateSourceCodeService();
sourceCodeService
.Compile(Arg.Is(buildProject), Arg.Any <IEnumerable <Calculation> >(), Arg.Any <CompilerOptions>())
.Returns(build);
IVersionRepository <CalculationVersion> calculationVersionRepository = CreateCalculationVersionRepository();
calculationVersionRepository
.CreateVersion(Arg.Any <CalculationVersion>(), Arg.Any <CalculationVersion>())
.Returns(calculationVersion);
ICacheProvider cacheProvider = CreateCacheProvider();
CalculationService calculationService = CreateCalculationService(
logger: logger,
calculationsRepository: calculationsRepository,
specificationRepository: specificationRepository,
buildProjectsService: buildProjectsService,
sourceCodeService: sourceCodeService,
calculationVersionRepository: calculationVersionRepository,
cacheProvider: cacheProvider);
//Act
await calculationService.ResetCalculationForFieldDefinitionChanges(relationships, specificationId, currentFieldDefinitionNames);
//Assert
await
sourceCodeService
.Received(1)
.DeleteAssembly(Arg.Is(specificationId));
await
cacheProvider
.Received(1)
.RemoveAsync <List <DatasetSchemaRelationshipModel> >(Arg.Is($"{CacheKeys.DatasetRelationshipFieldsForSpecification}{specificationId}"));
}
public async Task CreateCalculation_GivenValidCalculationWithNullFundingStream_AndSavesLogs()
{
//Arrange
Calculation calculation = CreateCalculation();
calculation.FundingStream = null;
IEnumerable <Calculation> calculations = new[]
{
calculation
};
IEnumerable <Models.Specs.Calculation> calculationSpecifications = new[]
{
new Models.Specs.Calculation
{
Id = calculation.CalculationSpecification.Id
}
};
string json = JsonConvert.SerializeObject(calculation);
Message message = new Message(Encoding.UTF8.GetBytes(json));
message.UserProperties.Add("user-id", UserId);
message.UserProperties.Add("user-name", Username);
ICalculationsRepository repository = CreateCalculationsRepository();
repository
.CreateDraftCalculation(Arg.Any <Calculation>())
.Returns(HttpStatusCode.Created);
repository
.GetCalculationsBySpecificationId(Arg.Is("any-spec-id"))
.Returns(calculations);
Models.Specs.SpecificationSummary specificationSummary = new Models.Specs.SpecificationSummary()
{
Id = calculation.SpecificationId,
Name = "Test Spec Name",
};
ISpecificationRepository specificationRepository = CreateSpecificationRepository();
specificationRepository
.GetSpecificationSummaryById(Arg.Is(calculation.SpecificationId))
.Returns(specificationSummary);
specificationRepository
.GetCalculationSpecificationsForSpecification(Arg.Is(calculation.SpecificationId))
.Returns(calculationSpecifications);
ILogger logger = CreateLogger();
ISearchRepository <CalculationIndex> searchRepository = CreateSearchRepository();
Build build = new Build
{
SourceFiles = new List <SourceFile> {
new SourceFile()
}
};
ISourceCodeService sourceCodeService = CreateSourceCodeService();
sourceCodeService
.Compile(Arg.Any <BuildProject>(), Arg.Any <IEnumerable <Models.Calcs.Calculation> >(), Arg.Any <CompilerOptions>())
.Returns(build);
CalculationService service = CreateCalculationService(
calculationsRepository: repository,
logger: logger, searchRepository:
searchRepository,
specificationRepository: specificationRepository,
sourceCodeService: sourceCodeService);
//Act
await service.CreateCalculation(message);
//Assert
logger
.Received(1)
.Information($"Calculation with id: {calculation.Id} was successfully saved to Cosmos Db");
await
repository
.Received(1)
.CreateDraftCalculation(Arg.Is <Calculation>(m =>
m.Id == CalculationId &&
m.Current.PublishStatus == PublishStatus.Draft &&
m.Current.Author.Id == UserId &&
m.Current.Author.Name == Username &&
m.Current.Date.Date == DateTimeOffset.Now.Date &&
m.Current.Version == 1 &&
m.Current.DecimalPlaces == 6
));
await
searchRepository
.Received(1)
.Index(Arg.Is <List <CalculationIndex> >(
m => m.First().Id == CalculationId &&
m.First().Name == "Test Calc Name" &&
m.First().CalculationSpecificationId == "any-calc-id" &&
m.First().CalculationSpecificationName == "Test Calc Name" &&
m.First().SpecificationId == "any-spec-id" &&
m.First().SpecificationName == "Test Spec Name" &&
m.First().FundingPeriodId == "18/19" &&
m.First().FundingPeriodName == "2018/2019" &&
m.First().FundingStreamId == string.Empty &&
m.First().FundingStreamName == "No funding stream set" &&
m.First().AllocationLineId == "test-alloc-id" &&
m.First().AllocationLineName == "test-alloc-name" &&
m.First().PolicySpecificationIds.First() == "policy-id" &&
m.First().PolicySpecificationNames.First() == "policy-name"
));
}
public async Task CreateCalculation_GivenValidCalculation_ButFailedToSave_DoesNotUpdateSearch()
{
//Arrange
Calculation calculation = CreateCalculation();
IEnumerable <Calculation> calculations = new[]
{
calculation
};
IEnumerable <Models.Specs.Calculation> calculationSpecifications = new[]
{
new Models.Specs.Calculation
{
Id = calculation.CalculationSpecification.Id
}
};
string json = JsonConvert.SerializeObject(calculation);
Message message = new Message(Encoding.UTF8.GetBytes(json));
message.UserProperties.Add("user-id", UserId);
message.UserProperties.Add("user-name", Username);
ICalculationsRepository repository = CreateCalculationsRepository();
repository
.CreateDraftCalculation(Arg.Any <Calculation>())
.Returns(HttpStatusCode.BadRequest);
repository
.GetCalculationsBySpecificationId(Arg.Is("any-spec-id"))
.Returns(calculations);
ILogger logger = CreateLogger();
ISearchRepository <CalculationIndex> searchRepository = CreateSearchRepository();
Models.Specs.SpecificationSummary specificationSummary = new Models.Specs.SpecificationSummary()
{
Id = calculation.SpecificationId,
Name = "Test Spec Name",
};
ISpecificationRepository specificationRepository = CreateSpecificationRepository();
specificationRepository
.GetSpecificationSummaryById(Arg.Is(calculation.SpecificationId))
.Returns(specificationSummary);
specificationRepository
.GetCalculationSpecificationsForSpecification(Arg.Is(calculation.SpecificationId))
.Returns(calculationSpecifications);
CalculationService service = CreateCalculationService(calculationsRepository: repository, logger: logger, searchRepository: searchRepository, specificationRepository: specificationRepository);
//Act
await service.CreateCalculation(message);
//Assert
logger
.Received(1)
.Error($"There was problem creating a new calculation with id {calculation.Id} in Cosmos Db with status code 400");
await
repository
.Received(1)
.CreateDraftCalculation(Arg.Is <Calculation>(m =>
m.Id == CalculationId &&
m.Current.PublishStatus == PublishStatus.Draft &&
m.Current.Author.Id == UserId &&
m.Current.Author.Name == Username &&
m.Current.Date.Date == DateTimeOffset.Now.Date &&
m.Current.Version == 1 &&
m.Current.DecimalPlaces == 6
));
await
searchRepository
.DidNotReceive()
.Index(Arg.Any <List <CalculationIndex> >());
}