public async Task CreateAdditionalCalculation_GivenCreateJobReturnsNull_ReturnsInternalServerError()
{
//Arrange
CalculationCreateModel model = CreateCalculationCreateModel();
Reference author = CreateAuthor();
ICalculationsRepository calculationsRepository = CreateCalculationsRepository();
calculationsRepository
.CreateDraftCalculation(Arg.Any <Calculation>())
.Returns(HttpStatusCode.OK);
IVersionRepository <CalculationVersion> versionRepository = CreateCalculationVersionRepository();
ISearchRepository <CalculationIndex> searchRepository = CreateSearchRepository();
IJobManagement jobManagement = CreateJobManagement();
jobManagement
.QueueJob(Arg.Any <JobCreateModel>())
.Returns((Job)null);
ISpecificationsApiClient specificationsApiClient = CreateSpecificationsApiClient();
specificationsApiClient
.GetSpecificationSummaryById(Arg.Is(SpecificationId))
.Returns(new ApiResponse <SpecificationSummary>(
HttpStatusCode.OK,
new SpecificationSummary {
Id = SpecificationId
}
));
ILogger logger = CreateLogger();
CalculationService calculationService = CreateCalculationService(
calculationsRepository: calculationsRepository,
calculationVersionRepository: versionRepository,
searchRepository: searchRepository,
jobManagement: jobManagement,
logger: logger,
specificationsApiClient: specificationsApiClient);
//Act
IActionResult result = await calculationService.CreateAdditionalCalculation(SpecificationId, model, author, CorrelationId);
//Assert
result
.Should()
.BeOfType <InternalServerErrorResult>()
.Which
.Value
.Should()
.Be($"Failed to create job of type '{JobConstants.DefinitionNames.CreateInstructAllocationJob}' on specification '{SpecificationId}'");
logger
.Received(1)
.Error(Arg.Is($"Failed to create job of type '{JobConstants.DefinitionNames.CreateInstructAllocationJob}' on specification '{SpecificationId}'"));
}
public CreateCalculationService(ICalculationNameInUseCheck calculationNameInUseCheck,
ICalculationsRepository calculationsRepository,
IVersionRepository <CalculationVersion> calculationVersionRepository,
ICalcsResiliencePolicies calculationsResiliencePolicies,
IValidator <CalculationCreateModel> calculationCreateModelValidator,
ICacheProvider cacheProvider,
ISearchRepository <CalculationIndex> searchRepository,
ILogger logger,
IInstructionAllocationJobCreation instructionAllocationJobCreation)
{
Guard.ArgumentNotNull(searchRepository, nameof(searchRepository));
Guard.ArgumentNotNull(calculationNameInUseCheck, nameof(calculationNameInUseCheck));
Guard.ArgumentNotNull(calculationsRepository, nameof(calculationsRepository));
Guard.ArgumentNotNull(calculationVersionRepository, nameof(calculationVersionRepository));
Guard.ArgumentNotNull(cacheProvider, nameof(cacheProvider));
Guard.ArgumentNotNull(calculationsResiliencePolicies?.CacheProviderPolicy, nameof(calculationsResiliencePolicies.CacheProviderPolicy));
Guard.ArgumentNotNull(calculationsResiliencePolicies?.CalculationsRepository, nameof(calculationsResiliencePolicies.CalculationsRepository));
Guard.ArgumentNotNull(calculationsResiliencePolicies?.CalculationsVersionsRepositoryPolicy, nameof(calculationsResiliencePolicies.CalculationsVersionsRepositoryPolicy));
_calculationNameInUseCheck = calculationNameInUseCheck;
_calculationsRepository = calculationsRepository;
_calculationVersionRepository = calculationVersionRepository;
_logger = logger;
_instructionAllocationJobCreation = instructionAllocationJobCreation;
_searchRepository = searchRepository;
_cacheProvider = cacheProvider;
_calculationCreateModelValidator = calculationCreateModelValidator;
_calculationVersionsRepositoryPolicy = calculationsResiliencePolicies.CalculationsVersionsRepositoryPolicy;
_calculationRepositoryPolicy = calculationsResiliencePolicies.CalculationsRepository;
_cachePolicy = calculationsResiliencePolicies.CacheProviderPolicy;
_typeIdentifierGenerator = new VisualBasicTypeIdentifierGenerator();
}
public void SetUp()
{
ILogger logger = Substitute.For <ILogger>();
IConfiguration configuration = Substitute.For <IConfiguration>();
_publishedFundingBulkRepository = Substitute.For <IPublishedFundingBulkRepository>();
_publishedFundingVersionRepository = Substitute.For <IVersionRepository <PublishedFundingVersion> >();
_publishedFundingVersionBulkRepository = Substitute.For <IVersionBulkRepository <PublishedFundingVersion> >();
_publishedFundingIdGeneratorResolver = Substitute.For <IPublishedFundingIdGeneratorResolver>();
_author = new Reference {
Id = "authorId", Name = "author"
};
_publishedFundingStatusUpdateService = new PublishedFundingStatusUpdateService(PublishingResilienceTestHelper.GenerateTestPolicies(),
_publishedFundingVersionRepository,
_publishedFundingIdGeneratorResolver,
logger,
new PublishingEngineOptions(configuration),
_publishedFundingVersionBulkRepository,
_publishedFundingBulkRepository);
_publishedFundingPeriod = new PublishedFundingPeriod {
Type = PublishedFundingPeriodType.AY, Period = "123"
};
}
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 FundingStreamPermissionService(
IUserRepository userRepository,
ISpecificationsApiClient specificationsApiClient,
IVersionRepository <FundingStreamPermissionVersion> fundingStreamPermissionVersionRepository,
ICacheProvider cacheProvider,
IMapper mapper,
ILogger logger,
IUsersResiliencePolicies policies)
{
Guard.ArgumentNotNull(userRepository, nameof(userRepository));
Guard.ArgumentNotNull(specificationsApiClient, nameof(specificationsApiClient));
Guard.ArgumentNotNull(fundingStreamPermissionVersionRepository, nameof(fundingStreamPermissionVersionRepository));
Guard.ArgumentNotNull(cacheProvider, nameof(cacheProvider));
Guard.ArgumentNotNull(mapper, nameof(mapper));
Guard.ArgumentNotNull(logger, nameof(logger));
Guard.ArgumentNotNull(policies?.UserRepositoryPolicy, nameof(policies.UserRepositoryPolicy));
Guard.ArgumentNotNull(policies?.SpecificationApiClient, nameof(policies.SpecificationApiClient));
Guard.ArgumentNotNull(policies?.FundingStreamPermissionVersionRepositoryPolicy, nameof(policies.FundingStreamPermissionVersionRepositoryPolicy));
Guard.ArgumentNotNull(policies?.CacheProviderPolicy, nameof(policies.CacheProviderPolicy));
_userRepository = userRepository;
_specificationsApiClient = specificationsApiClient;
_fundingStreamPermissionVersionRepository = fundingStreamPermissionVersionRepository;
_cacheProvider = cacheProvider;
_mapper = mapper;
_logger = logger;
_userRepositoryPolicy = policies.UserRepositoryPolicy;
_specificationsApiClientPolicy = policies.SpecificationApiClient;
_fundingStreamPermissionVersionRepositoryPolicy = policies.FundingStreamPermissionVersionRepositoryPolicy;
_cacheProviderPolicy = policies.CacheProviderPolicy;
}
public BaseApiController(TRepository repository, IVersionRepository versionRepository, Wrapper <ILog> logger)
{
Repository = repository;
Logger = logger;
VersionRepository = versionRepository;
IsVisibleExceptionRemoute = Convert.ToBoolean(ConfigurationManager.AppSettings["IsVisibleExceptionRemoute"]);
}
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 VersionManager(
IBlobContainer <VersionContainer> container,
IVersionRepository versionRepository)
{
VersionBlobContainer = container;
VersionRepository = versionRepository;
}
public PublishedFundingStatusUpdateService(
IPublishingResiliencePolicies publishingResiliencePolicies,
IVersionRepository <PublishedFundingVersion> publishedFundingVersionRepository,
IPublishedFundingIdGeneratorResolver publishedFundingIdGeneratorResolver,
ILogger logger,
IPublishingEngineOptions publishingEngineOptions,
IVersionBulkRepository <PublishedFundingVersion> publishedFundingVersionBulkRepository,
IPublishedFundingBulkRepository publishedFundingBulkRepository)
{
Guard.ArgumentNotNull(publishingResiliencePolicies?.PublishedFundingRepository, nameof(publishingResiliencePolicies.PublishedFundingRepository));
Guard.ArgumentNotNull(publishingResiliencePolicies?.PublishedProviderVersionRepository, nameof(publishingResiliencePolicies.PublishedProviderVersionRepository));
Guard.ArgumentNotNull(publishedFundingVersionRepository, nameof(publishedFundingVersionRepository));
Guard.ArgumentNotNull(logger, nameof(logger));
Guard.ArgumentNotNull(publishingEngineOptions, nameof(publishingEngineOptions));
Guard.ArgumentNotNull(publishedFundingVersionBulkRepository, nameof(publishedFundingVersionBulkRepository));
Guard.ArgumentNotNull(publishedFundingBulkRepository, nameof(publishedFundingBulkRepository));
_publishingResiliencePolicy = publishingResiliencePolicies.PublishedFundingRepository;
_publishedFundingVersionRepository = publishedFundingVersionRepository;
_publishedFundingIdGeneratorResolver = publishedFundingIdGeneratorResolver;
_logger = logger;
_publishingEngineOptions = publishingEngineOptions;
_publishedFundingVersionBulkRepository = publishedFundingVersionBulkRepository;
_publishedFundingBulkRepository = publishedFundingBulkRepository;
_versionRepositoryPolicy = publishingResiliencePolicies.PublishedProviderVersionRepository;
}
async public Task GetCalculationHistory_GivenCalculationIdWasProvidedButHistoryWasNull_ReturnsNotFound()
{
//Arrange
ILogger logger = CreateLogger();
IVersionRepository <CalculationVersion> versionsRepository = CreateCalculationVersionRepository();
versionsRepository
.GetVersions(Arg.Is(CalculationId))
.Returns((IEnumerable <CalculationVersion>)null);
CalculationService service = CreateCalculationService(logger: logger, calculationVersionRepository: versionsRepository);
//Act
IActionResult result = await service.GetCalculationHistory(CalculationId);
//Assert
result
.Should()
.BeOfType <NotFoundResult>();
logger
.Received(1)
.Information(Arg.Is($"A calculation was not found for calculation id {CalculationId}"));
}
async public Task GetCalculationHistory_GivenCalculationIdWasProvided_ReturnsOK()
{
//Arrange
IEnumerable <CalculationVersion> versions = new List <CalculationVersion>
{
new CalculationVersion(),
new CalculationVersion()
};
ILogger logger = CreateLogger();
IVersionRepository <CalculationVersion> versionsRepository = CreateCalculationVersionRepository();
versionsRepository
.GetVersions(Arg.Is(CalculationId))
.Returns(versions);
CalculationService service = CreateCalculationService(logger: logger, calculationVersionRepository: versionsRepository);
//Act
IActionResult result = await service.GetCalculationHistory(CalculationId);
//Assert
result
.Should()
.BeOfType <OkObjectResult>();
}
/// <summary>
/// Creates a new instance of <see cref="AttachVersionTagToIncident"/>.
/// </summary>
/// <param name="repository">repos</param>
public AttachVersionTagToIncident(IVersionRepository repository)
{
if (repository == null)
{
throw new ArgumentNullException("repository");
}
_repository = repository;
}
public ProjectModel(
IUserRepository userRepository,
IProjectRepository projectRepository,
IVersionRepository versionRepository)
{
_userRepository = userRepository;
_projectRepository = projectRepository;
_versionRepository = versionRepository;
}
public ReadModelEventHandler(
IReadModelRepository readModelRepository,
IVersionRepository versionRepository,
IEventFeed <ReadModelEventHandler <T> > eventFeed)
{
_readModelRepository = readModelRepository;
_versionRepository = versionRepository;
_eventFeed = eventFeed;
}
public AsyncEventHandler(
IVersionRepository versionRepository,
IEventFeed <AsyncEventHandler <TConcreteHandlerType, TSubscribedDomainEvent> > eventFeed,
IHandleAsync <TSubscribedDomainEvent> handler)
{
_versionRepository = versionRepository;
_eventFeed = eventFeed;
_handler = handler;
}
public HmmNoteManager(IVersionRepository <HmmNote> noteRepo, IHmmValidator <HmmNote> validator, IDateTimeProvider dateProvider)
{
Guard.Against <ArgumentNullException>(noteRepo == null, nameof(noteRepo));
Guard.Against <ArgumentNullException>(validator == null, nameof(validator));
Guard.Against <ArgumentNullException>(dateProvider == null, nameof(dateProvider));
_noteRepo = noteRepo;
_validator = validator;
_dateProvider = dateProvider;
}
public VersionService(IExceptionService exceptionService, IConfiguration configuration,
ILogger <VersionService> logger, IVersionRepository versionRepository)
{
_exceptionService = exceptionService;
_configuration = configuration;
_logger = logger;
_versionRepository = versionRepository;
_appSettings = configuration.Get <AppSettings>();
}
public Runner(IDataClient dataClient, Assembly targetAssembly, IVersionRepository versionRepository)
{
_dataClient = dataClient;
_databaseKind = _dataClient.Database.Provider.DatabaseKind;
_targetAssembly = targetAssembly ?? Assembly.GetCallingAssembly();
VersionRepository = versionRepository;
_migrationFactory = new MigrationFactory(_dataClient);
_initialVersion = -1;
}
public Runner(IDataClient dataClient, Assembly targetAssembly, IVersionRepository versionRepository)
{
_dataClient = dataClient;
_databaseKind = _dataClient.Database.Provider.DatabaseKind;
_targetAssembly = targetAssembly ?? Assembly.GetCallingAssembly();
VersionRepository = versionRepository;
_migrationFactory = new MigrationFactory(_dataClient);
_initialVersion = -1;
}
public async Task AssignDataDefinitionRelationship_GivenUpdatedCosmosAndSearch_LogsSuccess()
{
//Arrange
dynamic anyObject = new { specificationId = SpecificationId, relationshipId = RelationshipId };
string json = JsonConvert.SerializeObject(anyObject);
Message message = new Message(Encoding.UTF8.GetBytes(json));
Specification specification = new Specification
{
Id = SpecificationId,
Name = SpecificationName,
Current = new Models.Specs.SpecificationVersion()
{
FundingStreams = new List <Reference>()
{
new Reference("fs-id", "fs-name")
},
FundingPeriod = new Reference("18/19", "2018/19"),
},
};
ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository();
specificationsRepository
.GetSpecificationById(Arg.Is(SpecificationId))
.Returns(specification);
specificationsRepository
.UpdateSpecification(Arg.Is(specification))
.Returns(HttpStatusCode.OK);
ILogger logger = CreateLogger();
Models.Specs.SpecificationVersion newSpecVersion = specification.Current.Clone() as Models.Specs.SpecificationVersion;
IVersionRepository <Models.Specs.SpecificationVersion> versionRepository = CreateVersionRepository();
versionRepository
.CreateVersion(Arg.Any <Models.Specs.SpecificationVersion>(), Arg.Any <Models.Specs.SpecificationVersion>())
.Returns(newSpecVersion);
SpecificationsService service = CreateService(specificationsRepository: specificationsRepository, logs: logger, specificationVersionRepository: versionRepository);
//Act
await service.Process(message);
//Assert
logger
.Received(1)
.Information($"Successfully assigned relationship id: {RelationshipId} to specification with id: {SpecificationId}");
await _specificationIndexer
.Received(1)
.Index(Arg.Is <Specification>(_ => ReferenceEquals(_.Current, newSpecVersion)));
}
public GetCommand(SetupParameters setupParameters,
IVersionRepository versionRepository)
{
_setupParameters = setupParameters;
_utility = new ConsoleUtility();
_versionRepository = versionRepository;
}
public QueryEventHandler(
IReadModelRepository readModelRepository,
IVersionRepository versionRepository,
IEventFeed <QueryEventHandler <TQuerry, TEvent> > eventFeed)
{
_readModelRepository = readModelRepository;
_versionRepository = versionRepository;
_eventFeed = eventFeed;
}
public PadSyncHandler(
PadServiceRepo padRepo,
IVersionRepository versionRepository,
IMatchEventRepository matchEventRepository
)
{
_padRepo = padRepo;
_versionRepository = versionRepository;
_matchEventRepository = matchEventRepository;
}
public VersionController(ILogger <VersionController> logger,
IRepository <AppVersion> repository,
IVersionRepository versionRepository,
IMapper mapper)
{
_logger = logger;
_repository = repository;
_versionRepository = versionRepository;
_mapper = mapper;
}
public NoteValidator(IVersionRepository <HmmNote> noteRepo)
{
Guard.Against <ArgumentNullException>(noteRepo == null, nameof(noteRepo));
_dataRepo = noteRepo;
RuleFor(n => n.Subject).NotNull().Length(1, 1000);
RuleFor(n => n.Author).NotNull().Must(AuthorNotChanged).WithMessage("Cannot update note's author");
RuleFor(n => n.Description).Length(1, 1000);
RuleFor(n => n.Catalog).NotNull();
}
public PadSyncHandler(
MatchmakingServiceRepo matchmakingRepo,
IVersionRepository versionRepository,
IMatchEventRepository matchEventRepository
)
{
_matchmakingRepo = matchmakingRepo;
_versionRepository = versionRepository;
_matchEventRepository = matchEventRepository;
}
public VersionitConsole(string[] args,IVersionRepository versionRepository)
: base("Versionit")
{
_args = args;
_versionRepository = versionRepository;
_logger = new ConsoleUtility();
_setupParameters = new SetupParameters();
_fileUtility = new FileUtility();
_sqlMessageUtility = new SqlMessageUtility();
}
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 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 CreateVersion_GivenValidInputWithCurrentVersion_EnsuresCallsCreateVersionWithCorrectParameters()
{
//Arrange
const string providerId = "123";
const string fundingPeriodId = "456";
const string fundingStreamId = "789";
string partitionKey = $"publishedprovider-{providerId}-{fundingPeriodId}-{fundingStreamId}";
PublishedProviderCreateVersionRequest publishedProviderCreateVersionRequest = new PublishedProviderCreateVersionRequest
{
PublishedProvider = new PublishedProvider
{
Current = new PublishedProviderVersion
{
ProviderId = providerId,
FundingPeriodId = fundingPeriodId,
FundingStreamId = fundingStreamId
}
},
NewVersion = new PublishedProviderVersion
{
ProviderId = providerId,
FundingPeriodId = fundingPeriodId,
FundingStreamId = fundingStreamId
}
};
IEnumerable <PublishedProviderCreateVersionRequest> versions = new[]
{
publishedProviderCreateVersionRequest
};
ILogger logger = CreateLogger();
IVersionRepository <PublishedProviderVersion> versionRepository = CreateVersionRepository();
PublishedProviderVersioningService service = CreateVersioningService(logger, versionRepository);
//Act
IEnumerable <PublishedProvider> result = await service.CreateVersions(versions);
//Assert
await
versionRepository
.Received(1)
.CreateVersion(
Arg.Is(publishedProviderCreateVersionRequest.NewVersion),
Arg.Is <PublishedProviderVersion>(m =>
m.ProviderId == providerId &&
m.FundingPeriodId == fundingPeriodId &&
m.FundingStreamId == fundingStreamId),
Arg.Is(partitionKey));
}
public ReadModelHandler(
IMatchEventRepository eventRepository,
IVersionRepository versionRepository,
T innerHandler,
TrackingService trackingService = null)
{
_eventRepository = eventRepository;
_versionRepository = versionRepository;
_innerHandler = innerHandler;
_trackingService = trackingService;
}
public InstanceService(
IInstanceRepository instanceRepository,
IVersionRepository versionRepository,
ISiteRepository siteRepository,
IDatabaseService databaseService)
{
_instanceRepository = instanceRepository;
_versionRepository = versionRepository;
_siteRepository = siteRepository;
_databaseService = databaseService;
}
public LoaderServiceTest()
{
fHttpService = Substitute.For <IHttpService>();
fConfig = Substitute.For <ILoaderServiceConfig>();
fResourcesRepository = Substitute.For <IResourcesRepository>();
fVersionRepository = Substitute.For <IVersionRepository>();
fWoodyPlantRepository = Substitute.For <IWoodyPlantRepository>();
fHubContext = Substitute.For <IHubContext <ClientHub> >();
fService = new LoaderService(fHttpService, fConfig, fResourcesRepository, fVersionRepository, fWoodyPlantRepository, fHubContext);
}
public ScriptCommand(SetupParameters setupParameters,
IVersionRepository versionRepository,
IFileUtility fileUtility,
IMessageUtility messageUtility)
{
_setupParameters = setupParameters;
_utility = new ConsoleUtility();
_versionRepository = versionRepository;
_fileUtility = fileUtility;
_messageUtility = messageUtility;
}
public CreateCommand(SetupParameters setupParameters,
IVersionRepository versionRepository)
{
_setupParameters = setupParameters;
_versionRepository = versionRepository;
}
public MigrationInformation(IVersionRepository versionRepository)
{
_versionRepository = versionRepository;
}
public VersionController(IVersionRepository versionRepository)
{
_repository = versionRepository;
}
