Beispiel #1
0
        public void ForValuesShouldPassConfigurationActionToBuilder([Frozen, ManifestModel] ValidatorBuilderContext context,
                                                                    [Frozen] IGetsValidatorBuilderContext ruleContextFactory,
                                                                    [Frozen] IGetsValueAccessorBuilder valueBuilderFactory,
                                                                    ValidatorBuilder <ValidatedObject> sut,
                                                                    [ManifestModel] ValidatorBuilderContext ruleContext,
                                                                    IBuildsValueAccessor <ValidatedObject, char> valueBuilder,
                                                                    [ManifestModel] ManifestValue value)
        {
            Mock.Get(ruleContextFactory)
            .Setup(x => x.GetContextForValue(It.IsAny <Func <ValidatedObject, IEnumerable <char> > >(), context, false))
            .Returns(ruleContext);
            Mock.Get(ruleContextFactory)
            .Setup(x => x.GetContextForValue <ValidatedObject, char>(null, ruleContext, true))
            .Returns(ruleContext);
            Mock.Get(valueBuilderFactory)
            .Setup(x => x.GetValueAccessorBuilder <ValidatedObject, char>(ruleContext, It.IsAny <Action <IConfiguresValueAccessor <ValidatedObject, char> > >()))
            .Returns(valueBuilder);
            Mock.Get(valueBuilder)
            .Setup(x => x.GetManifestValue())
            .Returns(() => value);

            Action <IConfiguresValueAccessor <ValidatedObject, char> > configAction = c => c.AddRuleWithParent <CharValueRule>();

            sut.ForValues(x => x.AProperty, configAction);

            Mock.Get(valueBuilderFactory)
            .Verify(x => x.GetValueAccessorBuilder <ValidatedObject, char>(ruleContext, configAction), Times.Once);
        }
Beispiel #2
0
        public void ForValuesShouldAddBuilderReturnedFromValueBuilderFactory([Frozen, ManifestModel] ValidatorBuilderContext context,
                                                                             [Frozen] IGetsValidatorBuilderContext ruleContextFactory,
                                                                             [Frozen] IGetsValueAccessorBuilder valueBuilderFactory,
                                                                             ValidatorBuilder <ValidatedObject> sut,
                                                                             [ManifestModel] ValidatorBuilderContext ruleContext,
                                                                             IBuildsValueAccessor <ValidatedObject, char> valueBuilder,
                                                                             [ManifestModel] ManifestValue value)
        {
            Mock.Get(ruleContextFactory)
            .Setup(x => x.GetContextForValue(It.IsAny <Func <ValidatedObject, IEnumerable <char> > >(), context, false))
            .Returns(ruleContext);
            Mock.Get(ruleContextFactory)
            .Setup(x => x.GetContextForValue <ValidatedObject, char>(null, ruleContext, true))
            .Returns(ruleContext);
            Mock.Get(valueBuilderFactory)
            .Setup(x => x.GetValueAccessorBuilder <ValidatedObject, char>(ruleContext, It.IsAny <Action <IConfiguresValueAccessor <ValidatedObject, char> > >()))
            .Returns(valueBuilder);
            Mock.Get(valueBuilder)
            .Setup(x => x.GetManifestValue())
            .Returns(() => value);

            sut.ForValues(x => x.AProperty, c => {});

            Assert.That(sut.GetManifestValue().Children.Single(), Is.SameAs(value));
        }
 /// <summary>
 /// Initialises a new instance of <see cref="ValidatorBuilder{TValidated}"/>.
 /// </summary>
 /// <param name="ruleContextFactory">A factory for rule contexts.</param>
 /// <param name="ruleBuilderFactory">A factory for rule builders.</param>
 /// <param name="valueBuilderFactory">A factory for validator builders.</param>
 /// <param name="validatorManifestFactory">A factory for validator manifests.</param>
 /// <param name="context">
 /// A validator builder context for this validator builder to use.
 /// </param>
 public ValidatorBuilder(IGetsValidatorBuilderContext ruleContextFactory,
                         IGetsRuleBuilder ruleBuilderFactory,
                         IGetsValueAccessorBuilder valueBuilderFactory,
                         IGetsValidatorManifest validatorManifestFactory,
                         ValidatorBuilderContext context)
 {
     this.ruleContextFactory       = ruleContextFactory ?? throw new ArgumentNullException(nameof(ruleContextFactory));
     this.ruleBuilderFactory       = ruleBuilderFactory ?? throw new ArgumentNullException(nameof(ruleBuilderFactory));
     this.valueBuilderFactory      = valueBuilderFactory ?? throw new ArgumentNullException(nameof(valueBuilderFactory));
     this.validatorManifestFactory = validatorManifestFactory ?? throw new ArgumentNullException(nameof(validatorManifestFactory));
     this.context = context ?? throw new ArgumentNullException(nameof(context));
 }
Beispiel #4
0
        public void GetValidatorManifestWithRuleContextShouldReturnAValidatorBuilder([Frozen] IServiceProvider serviceProvider,
                                                                                     ImportedValidatorBuilderManifestFactory sut,
                                                                                     IGetsValidatorBuilderContext ruleContextFactory,
                                                                                     IGetsRuleBuilder ruleBuilderFactory,
                                                                                     IGetsValueAccessorBuilder valueBuilderFactory,
                                                                                     IGetsValidatorManifest validatorManifestFactory,
                                                                                     IResolvesServices resolver,
                                                                                     [ManifestModel] ValidatorBuilderContext context)
        {
            Mock.Get(serviceProvider).Setup(x => x.GetService(typeof(IGetsValidatorBuilderContext))).Returns(ruleContextFactory);
            Mock.Get(serviceProvider).Setup(x => x.GetService(typeof(IGetsRuleBuilder))).Returns(ruleBuilderFactory);
            Mock.Get(serviceProvider).Setup(x => x.GetService(typeof(IGetsValueAccessorBuilder))).Returns(valueBuilderFactory);
            Mock.Get(serviceProvider).Setup(x => x.GetService(typeof(IGetsValidatorManifest))).Returns(validatorManifestFactory);
            Mock.Get(serviceProvider).Setup(x => x.GetService(typeof(IResolvesServices))).Returns(resolver);
            Mock.Get(resolver).Setup(x => x.ResolveService <object>(typeof(GenericValidatorDefinition <object>))).Returns(() => new GenericValidatorDefinition <object>());

            var result = sut.GetValidatorManifest(typeof(GenericValidatorDefinition <object>), context);

            Assert.That(result, Is.InstanceOf <ValidatorBuilder <object> >());
        }
Beispiel #5
0
        public void ValidateAsAncestorShouldThrowIfForMemberHasAlreadyBeenUsed([Frozen, ManifestModel] ValidatorBuilderContext context,
                                                                               [Frozen] IGetsValidatorBuilderContext ruleContextFactory,
                                                                               [Frozen] IGetsValueAccessorBuilder valueBuilderFactory,
                                                                               ValidatorBuilder <ValidatedObject> sut,
                                                                               ValidatorBuilderContext ruleContext,
                                                                               IBuildsValueAccessor <ValidatedObject, string> valueBuilder,
                                                                               [ManifestModel] ManifestValue value)
        {
            Mock.Get(ruleContextFactory)
            .Setup(x => x.GetContextForMember(It.IsAny <Expression <Func <ValidatedObject, string> > >(), context, false))
            .Returns(ruleContext);
            Mock.Get(valueBuilderFactory)
            .Setup(x => x.GetValueAccessorBuilder <ValidatedObject, string>(ruleContext, It.IsAny <Action <IConfiguresValueAccessor <ValidatedObject, string> > >()))
            .Returns(valueBuilder);
            Mock.Get(valueBuilder)
            .Setup(x => x.GetManifestValue())
            .Returns(() => value);

            sut.ForMember(x => x.AProperty, v => { });
            Assert.That(() => sut.ValidateAsAncestor(1), Throws.InvalidOperationException);
        }
Beispiel #6
0
        public void GetValidatorManifestShouldExecuteConfigureValidatorFromDefinitionUponBuilder([Frozen] IServiceProvider serviceProvider,
                                                                                                 ImportedValidatorBuilderManifestFactory sut,
                                                                                                 IGetsValidatorBuilderContext ruleContextFactory,
                                                                                                 IGetsRuleBuilder ruleBuilderFactory,
                                                                                                 IGetsValueAccessorBuilder valueBuilderFactory,
                                                                                                 IGetsValidatorManifest validatorManifestFactory,
                                                                                                 IResolvesServices resolver,
                                                                                                 [ManifestModel] ValidatorBuilderContext context,
                                                                                                 ValidatedObject obj)
        {
            Mock.Get(serviceProvider).Setup(x => x.GetService(typeof(IGetsValidatorBuilderContext))).Returns(ruleContextFactory);
            Mock.Get(serviceProvider).Setup(x => x.GetService(typeof(IGetsRuleBuilder))).Returns(ruleBuilderFactory);
            Mock.Get(serviceProvider).Setup(x => x.GetService(typeof(IGetsValueAccessorBuilder))).Returns(valueBuilderFactory);
            Mock.Get(serviceProvider).Setup(x => x.GetService(typeof(IGetsValidatorManifest))).Returns(validatorManifestFactory);
            Mock.Get(serviceProvider).Setup(x => x.GetService(typeof(IResolvesServices))).Returns(resolver);
            Mock.Get(resolver).Setup(x => x.ResolveService <object>(typeof(ValidatedObjectDefinition))).Returns(() => new ValidatedObjectDefinition());

            sut.GetValidatorManifest(typeof(ValidatedObjectDefinition), context);

            Assert.That(() => context.ManifestValue.IdentityAccessor(obj),
                        Is.EqualTo(obj.Identity),
                        $@"Because the definition sets up the context to use the {nameof(ValidatedObject.Identity)} property
for identity, asserting that they are equal proves that the configuration function was executed.");
        }