Exemple #1
0
        public void Amendment_MigratedProducerExistsWithPrn_ReturnsFailAsWarning_AndIncludesProducerNamesInErrorMessage()
        {
            const string existingProducerName = "existing producer name";
            const string newProducerName      = "new producer Name";

            var migratedProducer = A.Fake <MigratedProducer>();

            A.CallTo(() => migratedProducer.ProducerName)
            .Returns(existingProducerName);

            A.CallTo(() => migratedProducerQuerySet.GetMigratedProducer(A <string> ._))
            .Returns(migratedProducer);

            var result = Rule().Evaluate(new schemeType(), new producerType
            {
                status           = statusType.A,
                producerBusiness = new producerBusinessType
                {
                    Item = new partnershipType
                    {
                        partnershipName = newProducerName
                    }
                }
            }, A.Dummy <Guid>());

            Assert.False(result.IsValid);
            Assert.Equal(Core.Shared.ErrorLevel.Warning, result.ErrorLevel);
            Assert.Contains(existingProducerName, result.Message);
            Assert.Contains(newProducerName, result.Message);
        }
        public ProducerNameChangeTests()
        {
            producerQuerySet = A.Fake<IProducerQuerySet>();
            migratedProducerQuerySet = A.Fake<IMigratedProducerQuerySet>();

            // By default, nulls returned from queries
            A.CallTo(() => producerQuerySet.GetLatestProducerForComplianceYearAndScheme(A<string>._, A<string>._, A<Guid>._))
                .Returns(null);
            A.CallTo(() => producerQuerySet.GetLatestProducerFromPreviousComplianceYears(A<string>._))
                .Returns(null);
            A.CallTo(() => migratedProducerQuerySet.GetMigratedProducer(A<string>._))
                .Returns(null);
            A.CallTo(() => producerQuerySet.GetProducerForOtherSchemeAndObligationType(A<string>._, A<string>._, A<Guid>._, A<ObligationType>._))
                .Returns(null);
        }
        public ProducerAlreadyRegisteredEvaluatorTests()
        {
            producerQuerySet         = A.Fake <IProducerQuerySet>();
            migratedProducerQuerySet = A.Fake <IMigratedProducerQuerySet>();

            // By default, nulls returned from queries
            A.CallTo(() => producerQuerySet.GetLatestProducerForComplianceYearAndScheme(A <string> ._, A <string> ._, A <Guid> ._))
            .Returns(null);
            A.CallTo(() => producerQuerySet.GetLatestProducerFromPreviousComplianceYears(A <string> ._))
            .Returns(null);
            A.CallTo(() => migratedProducerQuerySet.GetMigratedProducer(A <string> ._))
            .Returns(null);
            A.CallTo(() => producerQuerySet.GetProducerForOtherSchemeAndObligationType(A <string> ._, A <string> ._, A <Guid> ._, A <ObligationType> ._))
            .Returns(null);
        }
        public RuleResult Evaluate(schemeType scheme, producerType producer, Guid organisationId)
        {
            if (producer.status == statusType.A)
            {
                string existingProducerName = string.Empty;

                var existingProducer =
                    producerQuerySet.GetLatestProducerForComplianceYearAndScheme(producer.registrationNo,
                                                                                 scheme.complianceYear, organisationId) ??
                    producerQuerySet.GetLatestProducerFromPreviousComplianceYears(producer.registrationNo);

                if (existingProducer != null)
                {
                    existingProducerName = existingProducer.OrganisationName;
                }
                else
                {
                    var existingMigratedProducer = migratedProducerQuerySet.GetMigratedProducer(producer.registrationNo);

                    if (existingMigratedProducer == null)
                    {
                        // Producer doesn't exist so no warning
                        return(RuleResult.Pass());
                    }

                    existingProducerName = existingMigratedProducer.ProducerName;
                }

                if (existingProducerName != producer.GetProducerName())
                {
                    var errorMessage = string.Format("The producer name of {0} {1} will change from {0} to {2}.",
                                                     existingProducerName, producer.registrationNo, producer.GetProducerName());

                    return(RuleResult.Fail(errorMessage, Core.Shared.ErrorLevel.Warning));
                }
            }

            return(RuleResult.Pass());
        }