public async Task CollectsDetailsOfUnapprovedCalculationsAsValidationErrors()
        {
            CalculationMetadata calculation1 = NewApiCalculation(_ => _.WithPublishStatus(PublishStatus.Archived).WithCalculationType(CalculationType.Template));
            CalculationMetadata calculation2 = NewApiCalculation(_ => _.WithPublishStatus(PublishStatus.Approved).WithCalculationType(CalculationType.Template));
            CalculationMetadata calculation3 = NewApiCalculation(_ => _.WithPublishStatus(PublishStatus.Draft).WithCalculationType(CalculationType.Template));
            CalculationMetadata calculation4 = NewApiCalculation(_ => _.WithPublishStatus(PublishStatus.Approved).WithCalculationType(CalculationType.Template));
            CalculationMetadata calculation5 = NewApiCalculation(_ => _.WithPublishStatus(PublishStatus.Approved).WithCalculationType(CalculationType.Template));
            CalculationMetadata calculation6 = NewApiCalculation(_ => _.WithPublishStatus(PublishStatus.Updated).WithCalculationType(CalculationType.Template));
            CalculationMetadata calculation7 = NewApiCalculation(_ => _.WithPublishStatus(PublishStatus.Updated));

            string specificationId = NewRandomString();

            GivenTheCalculationsForTheSpecificationId(specificationId,
                                                      calculation1,
                                                      calculation2,
                                                      calculation3,
                                                      calculation4,
                                                      calculation5,
                                                      calculation6);

            await WhenThePreRequisitesAreChecked(specificationId);

            _validationErrors
            .Should()
            .Contain(new[]
            {
                $"Calculation {calculation1.Name} must be approved but is {calculation1.PublishStatus}",
                $"Calculation {calculation3.Name} must be approved but is {calculation3.PublishStatus}",
                $"Calculation {calculation6.Name} must be approved but is {calculation6.PublishStatus}"
            });
        }
        public async Task CollectDetailsOfNotMappedTemplateCalculationsAsValidationErrors()
        {
            CalculationMetadata calculation2 = NewApiCalculation(_ => _.WithPublishStatus(PublishStatus.Approved));
            CalculationMetadata calculation4 = NewApiCalculation(_ => _.WithPublishStatus(PublishStatus.Approved));
            CalculationMetadata calculation5 = NewApiCalculation(_ => _.WithPublishStatus(PublishStatus.Approved));

            string specificationId          = NewRandomString();
            string fundingStreamId          = NewRandomString();
            string templateMappingItemName1 = NewRandomString();

            TemplateMappingEntityType templateMappingEntityType1 = NewRandomEnum <TemplateMappingEntityType>();

            GivenTheCalculationsForTheSpecificationId(specificationId,
                                                      calculation2,
                                                      calculation4,
                                                      calculation5);

            TemplateMapping templateMapping = NewTemplateMapping(_ => _.WithItems(
                                                                     NewTemplateMappingItem(mi => mi.WithCalculationId(string.Empty).WithEntityType(templateMappingEntityType1).WithName(templateMappingItemName1)),
                                                                     NewTemplateMappingItem(mi => mi.WithCalculationId(NewRandomString()))));

            GivenTheTemplateMappingForTheSpecificationIdAndFundingStreamId(specificationId, fundingStreamId, templateMapping);

            FundingStream[] fundingStreams = new FundingStream[]
            {
                new FundingStream {
                    Id = fundingStreamId
                }
            };

            await WhenThePreRequisitesAreChecked(specificationId, fundingStreams);

            _validationErrors
            .Should()
            .Contain(new[]
            {
                $"{templateMappingEntityType1} {templateMappingItemName1} is not mapped to a calculation in CFS"
            });
        }