public async Task QueueApproveAllSpecificationCalculations_JobActionQueuesJob_ReturnsOKJobDetails()
        {
            string correlationId = "any-id";
            string jobId         = "any-id";


            Reference author = new Reference();
            Job       job    = new Job {
                Id = jobId
            };

            IApproveAllCalculationsJobAction approveAllCalculationsJobAction = CreateApproveAllCalculationsJobAction();

            approveAllCalculationsJobAction
            .Run(Arg.Is(SpecificationId), Arg.Is(author), Arg.Is(correlationId))
            .Returns(job);

            CalculationService calculationService = CreateCalculationService(approveAllCalculationsJobAction: approveAllCalculationsJobAction);

            IActionResult actionResult = await calculationService.QueueApproveAllSpecificationCalculations(SpecificationId, author, correlationId);

            actionResult
            .Should()
            .BeAssignableTo <OkObjectResult>()
            .And
            .NotBeNull();

            OkObjectResult okObjectResult = actionResult as OkObjectResult;

            okObjectResult.Value.Should().NotBeNull().And.BeAssignableTo <Job>();

            Job actualJob = okObjectResult.Value as Job;

            actualJob.Id.Should().Be(jobId);
        }
        public async Task QueueApproveAllSpecificationCalculations_JobActionThrowsException_ReturnsInternalServerErrorResult()
        {
            string correlationId = "any-id";

            Reference author = new Reference();

            IApproveAllCalculationsJobAction approveAllCalculationsJobAction = CreateApproveAllCalculationsJobAction();

            approveAllCalculationsJobAction
            .Run(Arg.Is(SpecificationId), Arg.Is(author), Arg.Is(correlationId))
            .Throws <Exception>();

            CalculationService calculationService = CreateCalculationService(approveAllCalculationsJobAction: approveAllCalculationsJobAction);

            IActionResult actionResult = await calculationService.QueueApproveAllSpecificationCalculations(SpecificationId, author, correlationId);

            actionResult
            .Should()
            .BeAssignableTo <InternalServerErrorResult>();
        }
        private static CalculationService CreateCalculationService(
            ICalculationsRepository calculationsRepository = null,
            ILogger logger = null,
            ISearchRepository <CalculationIndex> searchRepository = null,
            IBuildProjectsService buildProjectsService            = null,
            IPoliciesApiClient policiesApiClient        = null,
            ICacheProvider cacheProvider                = null,
            ICalcsResiliencePolicies resiliencePolicies = null,
            IVersionRepository <CalculationVersion> calculationVersionRepository = null,
            IJobManagement jobManagement                     = null,
            ISourceCodeService sourceCodeService             = null,
            IFeatureToggle featureToggle                     = null,
            IBuildProjectsRepository buildProjectsRepository = null,
            ICalculationCodeReferenceUpdate calculationCodeReferenceUpdate      = null,
            IValidator <CalculationCreateModel> calculationCreateModelValidator = null,
            IValidator <CalculationEditModel> calculationEditModelValidator     = null,
            ISpecificationsApiClient specificationsApiClient = null,
            IGraphRepository graphRepository = null,
            ICalculationsFeatureFlag calculationsFeatureFlag = null,
            ICodeContextCache codeContextCache         = null,
            ISourceFileRepository sourceFileRepository = null,
            IResultsApiClient resultsApiClient         = null,
            IDatasetsApiClient datasetsApiClient       = null,
            IApproveAllCalculationsJobAction approveAllCalculationsJobAction = null)
        {
            CalculationNameInUseCheck calculationNameInUseCheck = new CalculationNameInUseCheck(calculationsRepository ?? CreateCalculationsRepository(),
                                                                                                specificationsApiClient ?? CreateSpecificationsApiClient(),
                                                                                                resiliencePolicies ?? CalcsResilienceTestHelper.GenerateTestPolicies());

            InstructionAllocationJobCreation instructionAllocationJobCreation =
                new InstructionAllocationJobCreation(
                    calculationsRepository ?? CreateCalculationsRepository(),
                    resiliencePolicies ?? CalcsResilienceTestHelper.GenerateTestPolicies(),
                    logger ?? CreateLogger(),
                    calculationsFeatureFlag ?? CreateCalculationsFeatureFlag(),
                    jobManagement ?? CreateJobManagement());

            return(new CalculationService
                   (
                       calculationsRepository ?? CreateCalculationsRepository(),
                       logger ?? CreateLogger(),
                       searchRepository ?? CreateSearchRepository(),
                       buildProjectsService ?? CreateBuildProjectsService(),
                       policiesApiClient ?? CreatePoliciesApiClient(),
                       cacheProvider ?? CreateCacheProvider(),
                       resiliencePolicies ?? CalcsResilienceTestHelper.GenerateTestPolicies(),
                       calculationVersionRepository ?? CreateCalculationVersionRepository(),
                       sourceCodeService ?? CreateSourceCodeService(),
                       featureToggle ?? CreateFeatureToggle(),
                       buildProjectsRepository ?? CreateBuildProjectsRepository(),
                       calculationCodeReferenceUpdate ?? CreateCalculationCodeReferenceUpdate(),
                       calculationCreateModelValidator ?? CreateCalculationCreateModelValidator(),
                       calculationEditModelValidator ?? CreateCalculationEditModelValidator(),
                       specificationsApiClient ?? CreateSpecificationsApiClient(),
                       calculationNameInUseCheck,
                       instructionAllocationJobCreation,
                       new CreateCalculationService(calculationNameInUseCheck,
                                                    calculationsRepository ?? CreateCalculationsRepository(),
                                                    calculationVersionRepository ?? CreateCalculationVersionRepository(),
                                                    resiliencePolicies ?? CalcsResilienceTestHelper.GenerateTestPolicies(),
                                                    calculationCreateModelValidator ?? CreateCalculationCreateModelValidator(),
                                                    cacheProvider ?? CreateCacheProvider(),
                                                    searchRepository ?? CreateSearchRepository(),
                                                    logger ?? CreateLogger(),
                                                    instructionAllocationJobCreation),
                       graphRepository ?? CreateGraphRepository(),
                       CreateJobManagement(),
                       codeContextCache ?? Substitute.For <ICodeContextCache>(),
                       resultsApiClient ?? Substitute.For <IResultsApiClient>(),
                       datasetsApiClient ?? Substitute.For <IDatasetsApiClient>(),
                       approveAllCalculationsJobAction ?? CreateApproveAllCalculationsJobAction()));
        }