public void AccessorExceptionBehaviourShouldMarkTheManifestValueWithThatBehaviour([Frozen, ManifestModel] ValidatorBuilderContext context,
                                                                                   ValueAccessorBuilder <ValidatedObject, string> sut,
                                                                                   ValueAccessExceptionBehaviour behaviour)
 {
     ((ManifestValue)context.ManifestValue).AccessorExceptionBehaviour = behaviour;
     sut.AccessorExceptionBehaviour(behaviour);
     Assert.That(() => sut.GetManifestValue(), Has.Property(nameof(ManifestValue.AccessorExceptionBehaviour)).EqualTo(behaviour));
 }
        public void AddRulesShouldAddBuilderReturnedFromManifestFactory([Frozen] IGetsValidatorManifest manifestFactory,
                                                                        [Frozen, ManifestModel] ValidatorBuilderContext context,
                                                                        ValueAccessorBuilder <ValidatedObject, string> sut,
                                                                        IGetsManifestValue manifest,
                                                                        [ManifestModel] ManifestRule rule,
                                                                        [ManifestModel] ManifestValue value)
        {
            Mock.Get(manifestFactory)
            .Setup(x => x.GetValidatorManifest(typeof(StringValidator), context))
            .Returns(manifest);
            Mock.Get(manifest).Setup(x => x.GetManifestValue()).Returns(() => value);

            sut.AddRules <StringValidator>();

            Assert.That(sut.GetManifestValue().Children.Single(), Is.SameAs(value));
        }
        public void WhenValueIsShouldAddAPolymorphicTypeToTheManifestValue([Frozen] IGetsValidatorBuilderContext contextFactory,
                                                                           [Frozen, ManifestModel] ValidatorBuilderContext context,
                                                                           ValueAccessorBuilder <object, ValidatedObject> sut,
                                                                           [ManifestModel] ManifestPolymorphicType polymorphicType)
        {
            var derivedContext = new ValidatorBuilderContext(polymorphicType);

            Mock.Get(contextFactory).Setup(x => x.GetPolymorphicContext(context, typeof(DerivedValidatedObject))).Returns(derivedContext);
            sut.WhenValueIs <DerivedValidatedObject>(c => { });

            Assert.Multiple(() =>
            {
                var manifestValue = sut.GetManifestValue();
                Assert.That(manifestValue,
                            Is.InstanceOf <IHasPolymorphicTypes>(),
                            "Manifest value has polymorphic types.");
                Assert.That(manifestValue,
                            Has.Property(nameof(IHasPolymorphicTypes.PolymorphicTypes)).One.SameAs(polymorphicType),
                            "Manifest includes expected polymotphic type");
            });
        }
        public void GetManifestRulesShouldIterateOverEveryRuleAdded([Frozen, ManifestModel] ValidatorBuilderContext context,
                                                                    [Frozen] IGetsRuleBuilder ruleBuilderFactory,
                                                                    ValueAccessorBuilder <ValidatedObject, string> sut,
                                                                    [ManifestModel] ManifestValue value)
        {
            Mock.Get(ruleBuilderFactory)
            .Setup(x => x.GetRuleBuilder <StringValueRule>(It.IsAny <ValidatorBuilderContext>(), It.IsAny <Action <IConfiguresRule <StringValueRule> > >()))
            .Returns(() => {
                var ruleBuilder = new Mock <IBuildsRule <StringValueRule> >();
                ruleBuilder
                .Setup(x => x.GetManifestValue())
                .Returns(() => value);
                return(ruleBuilder.Object);
            });

            sut.AddRuleWithParent <StringValueRule>();
            sut.AddRuleWithParent <StringValueRule>();

            var manifestRules = sut.GetManifestValue().Rules.ToList();

            Mock.Get(ruleBuilderFactory)
            .Verify(x => x.GetRuleBuilder <StringValueRule>(context, It.IsAny <Action <IConfiguresRule <StringValueRule> > >()),
                    Times.Exactly(2));
        }
 public void GetManifestValueShouldNotMarkTheManifestValueWithAnExceptionBehaviourIfAccessorExceptionBehaviourWasNotCalled([Frozen, ManifestModel] ValidatorBuilderContext context,
                                                                                                                           ValueAccessorBuilder <ValidatedObject, string> sut)
 {
     ((ManifestValue)context.ManifestValue).AccessorExceptionBehaviour = null;
     Assert.That(() => sut.GetManifestValue(), Has.Property(nameof(ManifestValue.AccessorExceptionBehaviour)).Null);
 }