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);
}
