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)); }
public async Task GetValidationLogicShouldReturnWorkingLogicForRuleWhichOperatesOnCollectionOfStrings([Frozen] IResolvesRule ruleResolver, ValidationLogicFactory sut, string str, [RuleContext] RuleContext context) { var value = new ManifestValue { ValidatedType = typeof(IEnumerable <string>), CollectionItemValue = new ManifestCollectionItem { ValidatedType = typeof(string), }, }; var rule = new ManifestRule(value.CollectionItemValue, new ManifestRuleIdentifier(value.CollectionItemValue, typeof(StringRule))); value.Rules.Add(rule); var ruleBody = new StringRule(); Mock.Get(ruleResolver).Setup(x => x.ResolveRule(typeof(StringRule))).Returns(ruleBody); var result = sut.GetValidationLogic(rule); await result.GetResultAsync(str, null, context); Assert.That(ruleBody.Executed, Is.True); }
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); }
public void GetManifestRulesShouldIterateOverEveryRuleAdded([Frozen, ManifestModel] ValidatorBuilderContext context, [Frozen] IGetsValidatorBuilderContext ruleContextFactory, [Frozen] IGetsRuleBuilder ruleBuilderFactory, ValidatorBuilder <ValidatedObject> sut, [ManifestModel] ManifestValue value) { Mock.Get(ruleBuilderFactory) .Setup(x => x.GetRuleBuilder <ObjectRule>(It.IsAny <ValidatorBuilderContext>(), It.IsAny <Action <IConfiguresRule <ObjectRule> > >())) .Returns(() => { var ruleBuilder = new Mock <IBuildsRule <ObjectRule> >(); ruleBuilder .Setup(x => x.GetManifestValue()) .Returns(() => value); return(ruleBuilder.Object); }); sut.AddRule <ObjectRule>(); sut.AddRule <ObjectRule>(); sut.GetManifestValue(); Mock.Get(ruleBuilderFactory) .Verify(x => x.GetRuleBuilder <ObjectRule>(context, It.IsAny <Action <IConfiguresRule <ObjectRule> > >()), Times.Exactly(2)); }
/// <inheritdoc/> public IManifestItem GetManifestItem(ModelToManifestConversionContext context) { if (context.ConversionType != ModelToManifestConversionType.Manifest) { return(next.GetManifestItem(context)); } var manifestValue = new ManifestValue { Parent = context.ParentManifestValue, MemberName = context.MemberName, AccessorFromParent = context.AccessorFromParent, ValidatedType = context.ValidatedType, }; if (context.CurrentValue is Value val) { manifestValue.AccessorExceptionBehaviour = val.AccessorExceptionBehaviour; } if (context.ParentManifestValue != null) { context.ParentManifestValue.Children.Add(manifestValue); } return(manifestValue); }
public void GetValidatedValueShouldCreateCollectionValueFromFactoryIfManifestHasACollectionItem([Frozen] IGetsValidatedValueFromBasis valueFromBasisFactory, [Frozen] IGetsEnumerableItemsToBeValidated enumerableProvider, ValidatedValueFactory sut, IEnumerable <object> validatedValue, ResolvedValidationOptions validationOptions, [ExecutableModel] ValidatedValue value, [ExecutableModel] ValidatedValue collectionValue, object item) { var manifestValue = new ManifestValue { ValidatedType = typeof(IEnumerable <object>), CollectionItemValue = new ManifestCollectionItem { ValidatedType = typeof(object) }, }; Mock.Get(valueFromBasisFactory) .Setup(x => x.GetValidatedValue(It.Is <ValidatedValueBasis>(b => b.ManifestValue == manifestValue))) .Returns(value); value.ValueResponse = new SuccessfulGetValueToBeValidatedResponse(validatedValue); Mock.Get(enumerableProvider) .Setup(x => x.GetEnumerableItems(validatedValue, manifestValue.CollectionItemValue.ValidatedType)) .Returns(new[] { item }); Mock.Get(valueFromBasisFactory) .Setup(x => x.GetValidatedValue(It.Is <ValidatedValueBasis>(b => b.ManifestValue == manifestValue.CollectionItemValue && b.GetActualValue() == item))) .Returns(collectionValue); sut.GetValidatedValue(manifestValue, validatedValue, validationOptions); Mock.Get(valueFromBasisFactory) .Verify(x => x.GetValidatedValue(It.Is <ValidatedValueBasis>(b => b.ManifestValue == manifestValue.CollectionItemValue)), Times.Once); }
public void ValidateAsAncestorShouldThrowIfUsedTwice([Frozen, ManifestModel] ValidatorBuilderContext context, ValidatorBuilder <ValidatedObject> sut, [ManifestModel] ManifestValue parent) { context.ManifestValue.Parent = parent; sut.ValidateAsAncestor(1); Assert.That(() => sut.ValidateAsAncestor(1), Throws.InvalidOperationException); }
/// <summary> /// Gets a flattened collection of executable validation rules from a manifest value and object to be validated. /// </summary> /// <param name="manifestValue">The manifest value.</param> /// <param name="objectToBeValidated">The object to be validated.</param> /// <param name="options">The validation options.</param> /// <returns>A flattened collection of executable rules from the manifest value and the value's descendents.</returns> public IReadOnlyList <ExecutableRule> GetExecutableRules(ManifestValue manifestValue, object objectToBeValidated, ResolvedValidationOptions options) { var validatedValue = validatedValueProvider.GetValidatedValue(manifestValue, objectToBeValidated, options); return(GetFlattenedExecutableRules(validatedValue).ToList()); }
public void ForMemberShouldThrowIfValidateAsAncestorHasAlreadyBeenUsed([Frozen, ManifestModel] ValidatorBuilderContext context, ValidatorBuilder <ValidatedObject> sut, [ManifestModel] ManifestValue parent) { context.ManifestValue.Parent = parent; sut.ValidateAsAncestor(1); Assert.That(() => sut.ForMember(x => x.AProperty, v => { }), Throws.InvalidOperationException); }
static ValidatorBuilderContext CreateEmptyContext(Type validatedType) { var value = new ManifestValue { ValidatedType = validatedType }; return(new ValidatorBuilderContext(value)); }
public void GetManifestRuleIdentifierShouldThrowIfNoMatchingMemberIsFound(RelativeToManifestRuleIdentifierConverter sut, [ManifestModel] ManifestValue value, [ManifestModel] ManifestValue parent, Type ruleType) { value.Parent = parent; Assert.That(() => sut.GetManifestRuleIdentifier(value, new RelativeRuleIdentifier(ruleType, "NoMember", ancestorLevels: 1)), Throws.ArgumentException.And.Message.StartWith("The ManifestValue must have configuration for a member named \"NoMember\".")); }
public void GetBehaviourShouldReturnManifestBehaviourIfItIsNotNull(ValueAccessExceptionBehaviourProvider sut, [ManifestModel] ManifestValue manifestValue, ResolvedValidationOptions validationOptions, ValueAccessExceptionBehaviour valueBehaviour, ValueAccessExceptionBehaviour optionsBehaviour) { manifestValue.AccessorExceptionBehaviour = valueBehaviour; validationOptions.AccessorExceptionBehaviour = optionsBehaviour; Assert.That(() => sut.GetBehaviour(manifestValue, validationOptions), Is.EqualTo(valueBehaviour)); }
public void GetValueToBeValidatedShouldExposeTheCorrectValueWhenItIsReadable(ValueToBeValidatedProvider sut, [ManifestModel] ManifestValue manifestValue, object parentValue, ResolvedValidationOptions validationOptions, object expected) { manifestValue.AccessorFromParent = obj => expected; Assert.That(() => sut.GetValueToBeValidated(manifestValue, parentValue, validationOptions), Has.Property(nameof(SuccessfulGetValueToBeValidatedResponse.Value)).EqualTo(expected)); }
public void GetManifestItemShouldThrowIfNotEnoughAncestors([ManifestModel] ModelToManifestConversionContext context, ContextToRecursiveManifestItemConverter sut, [ManifestModel] ManifestValue parent, [ManifestModel] ManifestValue grandparent) { parent.Parent = grandparent; context.ParentManifestValue = parent; grandparent.Parent = null; context.ConversionType = ModelToManifestConversionType.RecursiveManifestValue; context.CurrentValue.ValidateRecursivelyAsAncestor = 3; Assert.That(() => sut.GetManifestItem(context), Throws.InstanceOf <ValidationException>()); }
public void GetValidatedValueShouldCreateCollectionValueFromFactoryIfManifestHasACollectionItemWithinAChildItem([Frozen] IGetsValidatedValueFromBasis valueFromBasisFactory, [Frozen] IGetsEnumerableItemsToBeValidated enumerableProvider, ValidatedValueFactory sut, IEnumerable <object> validatedValue, ResolvedValidationOptions validationOptions, [ExecutableModel] ValidatedValue value, [ExecutableModel] ValidatedValue childValue, [ExecutableModel] ValidatedValue collectionValue, object item) { var manifestValue = new ManifestValue { ValidatedType = typeof(object), Children = new[] { new ManifestValue { ValidatedType = typeof(IEnumerable <object>), CollectionItemValue = new ManifestCollectionItem { ValidatedType = typeof(object) }, } } }; Mock.Get(valueFromBasisFactory) .Setup(x => x.GetValidatedValue(It.Is <ValidatedValueBasis>(b => b.ManifestValue == manifestValue.Children.First()))) .Returns(childValue); Mock.Get(valueFromBasisFactory) .Setup(x => x.GetValidatedValue(It.Is <ValidatedValueBasis>(b => b.ManifestValue == manifestValue))) .Returns(value); value.ManifestValue = manifestValue; childValue.ManifestValue = manifestValue.Children.First(); collectionValue.ManifestValue = manifestValue.Children.First().CollectionItemValue; childValue.ValueResponse = new SuccessfulGetValueToBeValidatedResponse(validatedValue); Mock.Get(enumerableProvider) .Setup(x => x.GetEnumerableItems(validatedValue, manifestValue.Children.First().CollectionItemValue.ValidatedType)) .Returns(new[] { item }); Mock.Get(valueFromBasisFactory) .Setup(x => x.GetValidatedValue(It.Is <ValidatedValueBasis>(b => b.ManifestValue == manifestValue.Children.First().CollectionItemValue&& b.GetActualValue() == item))) .Returns(collectionValue); var result = sut.GetValidatedValue(manifestValue, validatedValue, validationOptions); Assert.Multiple(() => { Assert.That(result.CollectionItems, Is.Empty, "Root value has no collection items"); Assert.That(result.ChildValues, Has.Count.EqualTo(1), "Root value has one child value"); Assert.That(result.ChildValues.FirstOrDefault()?.CollectionItems, Has.Count.EqualTo(1), "Root value has one collection item"); }); }
public void AddRulesShouldAddBuilderReturnedFromManifestFactory([Frozen, ManifestModel] ValidatorBuilderContext context, [Frozen] IGetsValidatorManifest manifestFactory, ValidatorBuilder <ValidatedObject> sut, IGetsManifestValue manifest, [ManifestModel] ManifestValue value) { Mock.Get(manifestFactory) .Setup(x => x.GetValidatorManifest(typeof(ValidatedObjectValidator), context)) .Returns(manifest); Mock.Get(manifest).Setup(x => x.GetManifestValue()).Returns(() => value); sut.AddRules <ValidatedObjectValidator>(); Assert.That(sut.GetManifestValue().Children.Single(), Is.SameAs(value)); }
public void GetValidationLogicShouldThrowValidatorBuildingExceptionIfRuleIsWrongInterfaceForRule([Frozen] IResolvesRule ruleResolver, ValidationLogicFactory sut, string str) { var value = new ManifestValue { ValidatedType = typeof(string) }; var rule = new ManifestRule(value, new ManifestRuleIdentifier(value, typeof(object))); value.Rules.Add(rule); var ruleBody = new object(); Mock.Get(ruleResolver).Setup(x => x.ResolveRule(typeof(object))).Returns(ruleBody); Assert.That(() => sut.GetValidationLogic(rule), Throws.InstanceOf <ValidatorBuildingException>()); }
public void GetValidationLogicShouldThrowValidatorBuildingExceptionIfTheRuleConfigurationActionThrowsAnException([Frozen] IResolvesRule ruleResolver, ValidationLogicFactory sut, string str) { var value = new ManifestValue { ValidatedType = typeof(string) }; var rule = new ManifestRule(value, new ManifestRuleIdentifier(value, typeof(StringRule))); rule.RuleConfiguration = obj => throw new Exception(); value.Rules.Add(rule); var ruleBody = new StringRule(); Mock.Get(ruleResolver).Setup(x => x.ResolveRule(typeof(StringRule))).Returns(ruleBody); Assert.That(() => sut.GetValidationLogic(rule), Throws.InstanceOf <ValidatorBuildingException>()); }
/// <summary> /// Gets the validated value from the specified manifest value and object to be validated. /// </summary> /// <param name="manifestValue">The manifest value.</param> /// <param name="objectToBeValidated">The object to be validated.</param> /// <param name="options">The validation options.</param> /// <returns>A validated value, including a hierarchy of descendent values and /// the rules which may be executed upon those values.</returns> public ValidatedValue GetValidatedValue(ManifestValue manifestValue, object objectToBeValidated, ResolvedValidationOptions options) { if (manifestValue is null) { throw new ArgumentNullException(nameof(manifestValue)); } if (options is null) { throw new ArgumentNullException(nameof(options)); } var openList = new Queue <ValidatedValueBasis>(new [] { new ValidatedValueBasis(manifestValue, new SuccessfulGetValueToBeValidatedResponse(objectToBeValidated), null) }); ValidatedValue rootValidatedValue = null; while (openList.Any()) { var currentBasis = openList.Dequeue(); if (currentBasis.IsCircularReference()) { continue; } if (currentBasis.ValidatedValueResponse is IgnoredGetValueToBeValidatedResponse) { continue; } var currentValues = GetValidatedValues(currentBasis); if (rootValidatedValue is null && currentValues.Any()) { rootValidatedValue = currentValues.First(); } foreach (var value in currentValues) { FindAndAddChildrenToOpenList(currentBasis, value, openList, options); } } return(rootValidatedValue); }
public void AddRuleShouldAddRuleCreatedFromFactoryUsingContext([Frozen, ManifestModel] ValidatorBuilderContext context, [Frozen] IGetsValidatorBuilderContext ruleContextFactory, [Frozen] IGetsRuleBuilder ruleBuilderFactory, IBuildsRule <ObjectRule> ruleBuilder, ValidatorBuilder <ValidatedObject> sut, [ManifestModel] ManifestValue value) { Mock.Get(ruleBuilderFactory) .Setup(x => x.GetRuleBuilder <ObjectRule>(context, It.IsAny <Action <IConfiguresRule <ObjectRule> > >())) .Returns(ruleBuilder); Mock.Get(ruleBuilder) .Setup(x => x.GetManifestValue()) .Returns(() => value); sut.AddRule <ObjectRule>(); Assert.That(() => sut.GetManifestValue().Children.Single(), Is.SameAs(value)); }
public void GetValidatedValueShouldReturnSingleValueForManifestValueWithNoParentOrChildrenOrRules([Frozen] IGetsValidatedValueFromBasis valueFromBasisFactory, ValidatedValueFactory sut, object validatedValue, ResolvedValidationOptions validationOptions, [ExecutableModel] ValidatedValue value) { var manifestValue = new ManifestValue { ValidatedType = typeof(object) }; Mock.Get(valueFromBasisFactory) .Setup(x => x.GetValidatedValue(It.Is <ValidatedValueBasis>(b => b.ManifestValue == manifestValue))) .Returns(value); var result = sut.GetValidatedValue(manifestValue, validatedValue, validationOptions); Assert.That(result, Is.SameAs(value)); }
public void GetManifestItemShouldReturnAPolymorphicType([ManifestModel] ModelToManifestConversionContext context, ContextToManifestPolymorphicTypeConverter sut, [ManifestModel] ManifestValue parent) { context.ConversionType = ModelToManifestConversionType.PolymorphicType; context.ParentManifestValue = parent; context.PolymorphicTypeName = "System.String"; var result = sut.GetManifestItem(context); Assert.Multiple(() => { Assert.That(result, Is.InstanceOf <ManifestPolymorphicType>(), "Correct type"); Assert.That(result.Parent, Is.SameAs(parent), "Correct parent item"); Assert.That(result.ValidatedType, Is.EqualTo(typeof(string)), "Correct polymorphic type"); Assert.That(parent.PolymorphicTypes, Does.Contain(result), "Result added as one of parent's polymorphic types"); }); }
public void GetManifestItemShouldReturnACollectionItem([ManifestModel] ModelToManifestConversionContext context, ContextToManifestCollectionItemConverter sut, [ManifestModel] ManifestValue parent, [ManifestModel] ManifestValue grandparent) { context.ConversionType = ModelToManifestConversionType.CollectionItem; context.ParentManifestValue = parent; parent.Parent = grandparent; var result = sut.GetManifestItem(context); Assert.Multiple(() => { Assert.That(result, Is.InstanceOf <ManifestCollectionItem>(), "Correct type"); Assert.That(result.Parent, Is.SameAs(grandparent), "Correct parent item"); Assert.That(result.ValidatedType, Is.EqualTo(context.ValidatedType), "Correct validated type"); Assert.That(parent.CollectionItemValue, Is.SameAs(result), "Result added as parent's collection value"); }); }
static ValidatorBuilderContext GetContext(Func <object, object> accessor, ValidatorBuilderContext parentContext, Type validatedType, string memberName = null) { ManifestValue existingManifest; if (!(memberName is null) && (existingManifest = parentContext.ManifestValue.Children.OfType <ManifestValue>().FirstOrDefault(x => x.MemberName == memberName)) != null) { return(new ValidatorBuilderContext(existingManifest)); } var manifestValue = new ManifestValue { Parent = parentContext.ManifestValue, AccessorFromParent = accessor, MemberName = memberName, ValidatedType = validatedType, }; parentContext.ManifestValue.Children.Add(manifestValue); return(new ValidatorBuilderContext(manifestValue)); }
public void GetValidationLogicShouldThrowValidatorBuildingExceptionIfRuleWhichOperatesOnCollectionButValueIsNotEnumerable([Frozen] IResolvesRule ruleResolver, ValidationLogicFactory sut, string str) { var value = new ManifestValue { ValidatedType = typeof(int), CollectionItemValue = new ManifestCollectionItem { ValidatedType = typeof(int) } }; var rule = new ManifestRule(value.CollectionItemValue, new ManifestRuleIdentifier(value.CollectionItemValue, typeof(StringRule))); value.Rules.Add(rule); var ruleBody = new StringRule(); Mock.Get(ruleResolver).Setup(x => x.ResolveRule(typeof(StringRule))).Returns(ruleBody); Assert.That(() => sut.GetValidationLogic(rule), Throws.InstanceOf <ValidatorBuildingException>()); }
public async Task GetValidationLogicShouldReturnRuleThatUsesCorrectInterfaceWhenOriginalLogicWasAmbiguousBetweenRuleAndValueRule([Frozen] IResolvesRule ruleResolver, ValidationLogicFactory sut, string str, [RuleContext] RuleContext context) { var value = new ManifestValue { ValidatedType = typeof(string) }; var rule = new ManifestRule(value, new ManifestRuleIdentifier(value, typeof(StringValueRule))); value.Rules.Add(rule); var ruleBody = new StringValueRule(); Mock.Get(ruleResolver).Setup(x => x.ResolveRule(typeof(StringValueRule))).Returns(ruleBody); var result = sut.GetValidationLogic(rule); await result.GetResultAsync(str, null, context); Assert.That(ruleBody.ExecutedAsRule, Is.True); }
public void GetValidationLogicShouldConfigureRuleWithConfigurationAction([Frozen] IResolvesRule ruleResolver, ValidationLogicFactory sut, string str, string configValue) { var value = new ManifestValue { ValidatedType = typeof(string) }; var rule = new ManifestRule(value, new ManifestRuleIdentifier(value, typeof(StringRule))); rule.RuleConfiguration = obj => ((StringRule)obj).ConfigurableValue = configValue; value.Rules.Add(rule); var ruleBody = new StringRule(); Mock.Get(ruleResolver).Setup(x => x.ResolveRule(typeof(StringRule))).Returns(ruleBody); var result = sut.GetValidationLogic(rule); Assert.That(ruleBody.ConfigurableValue, Is.EqualTo(configValue)); }
static IEnumerable <CircularDependency> GetSomeCircularDependencies(ManifestValue manifestValue) { return(new[] { new CircularDependency { DependencyChain = new List <ExecutableRule> { new ExecutableRule { RuleIdentifier = new RuleIdentifier(typeof(string), typeof(int), "Identity 1", ruleName: "Foo"), }, new ExecutableRule { RuleIdentifier = new RuleIdentifier(typeof(DateTime), typeof(long), null), }, new ExecutableRule { RuleIdentifier = new RuleIdentifier(typeof(string), typeof(int), "Identity 1", ruleName: "Foo"), }, }, }, new CircularDependency { DependencyChain = new List <ExecutableRule> { new ExecutableRule { RuleIdentifier = new RuleIdentifier(typeof(string), typeof(int), "Identity 2", ruleName: "Bar"), }, new ExecutableRule { RuleIdentifier = new RuleIdentifier(typeof(object), typeof(long), null), }, new ExecutableRule { RuleIdentifier = new RuleIdentifier(typeof(string), typeof(int), "Identity 2", ruleName: "Bar"), }, }, }, }); }
public void AddRuleShouldProvideConfigFunctionToRuleBuilder([Frozen] IGetsRuleBuilder ruleBuilderFactory, [Frozen, ManifestModel] ValidatorBuilderContext context, ValueAccessorBuilder <ValidatedObject, string> sut, IBuildsRule <StringValueRule> ruleBuilder, [ManifestModel] ManifestRule rule, [ManifestModel] ManifestValue value) { Mock.Get(ruleBuilderFactory) .Setup(x => x.GetRuleBuilder <StringValueRule>(It.IsAny <ValidatorBuilderContext>(), It.IsAny <Action <IConfiguresRule <StringValueRule> > >())) .Returns(ruleBuilder); Mock.Get(ruleBuilder) .Setup(x => x.GetManifestValue()) .Returns(() => value); Action <IConfiguresRule <StringValueRule> > configFunction = r => { }; sut.AddRuleWithParent <StringValueRule>(configFunction); Mock.Get(ruleBuilderFactory) .Verify(x => x.GetRuleBuilder <StringValueRule>(It.IsAny <ValidatorBuilderContext>(), configFunction), Times.Once); }
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); }