public void GetContextForValueShouldReturnContextWithCorrectAccessor([ManifestModel] ValidatorBuilderContext validationContext,
                                                                             ValidatorBuilderContextFactory sut,
                                                                             ValidatedObject obj)
        {
            var result = sut.GetContextForValue <ValidatedObject, string>(v => v.AProperty, validationContext);

            Assert.That(() => ((ManifestValue)result.ManifestValue).AccessorFromParent(obj), Is.EqualTo(obj.AProperty));
        }
Beispiel #2
0
        public void UseObjectIdentityShouldAddIdentityAccessorToTheContext([Frozen, ManifestModel] ValidatorBuilderContext context,
                                                                           ValidatorBuilder <ValidatedObject> sut,
                                                                           ValidatedObject obj)
        {
            sut.UseObjectIdentity(x => x.Identity);

            Assert.That(() => context.ManifestValue.IdentityAccessor(obj), Is.EqualTo(obj.Identity));
        }
Beispiel #3
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.");
        }