static IEnumerable <ValidatedValue> GetCandidateValidatedValueMatches(ManifestRuleIdentifier dependencyIdentifier, ExecutableRule rule)
{
for (var currentValue = rule.ValidatedValue; currentValue != null; currentValue = currentValue.ParentValue)
{
yield return(GetMatchingValidatedValue(dependencyIdentifier, currentValue));
}
}
static ExecutableRule GetDependency(ManifestRuleIdentifier dependencyIdentifier, ExecutableRule rule)
{
var matchingValidatedValue = GetCandidateValidatedValueMatches(dependencyIdentifier, rule)
.FirstOrDefault(x => !(x is null));
if (matchingValidatedValue is null)
{
var message = String.Format(Resources.ExceptionMessages.GetExceptionMessage("CannotGetMatchingValueForDependency"),
rule.ManifestRule.Identifier,
dependencyIdentifier);
throw new ValidationException(message);
}
var dependency = matchingValidatedValue.Rules
.FirstOrDefault(valueRule => Equals(valueRule.ManifestRule.Identifier, dependencyIdentifier));
if (dependency == null)
{
var message = String.Format(Resources.ExceptionMessages.GetExceptionMessage("DependencyRuleNotOnMatchingValue"),
rule.ManifestRule.Identifier,
dependencyIdentifier);
throw new ValidationException(message);
}
return(dependency);
}
public void GetManifestRuleShouldReturnAManifestRuleWithCorrectDependencies([Frozen] IGetsManifestRuleIdentifierFromRelativeIdentifier relativeToManifestIdentityConverter,
[Frozen] IGetsManifestRuleIdentifier identifierFactory,
[Frozen, ManifestModel] ValidatorBuilderContext context,
RuleBuilder <SampleRule> sut,
[ManifestModel] ManifestRuleIdentifier identifier,
RelativeRuleIdentifier relativeId1,
RelativeRuleIdentifier relativeId2,
RelativeRuleIdentifier relativeId3,
[ManifestModel] ManifestRuleIdentifier manifestId1,
[ManifestModel] ManifestRuleIdentifier manifestId2,
[ManifestModel] ManifestRuleIdentifier manifestId3)
{
Mock.Get(identifierFactory)
.Setup(x => x.GetManifestRuleIdentifier(typeof(SampleRule), It.IsAny <ValidatorBuilderContext>(), It.IsAny <string>()))
.Returns(identifier);
Mock.Get(relativeToManifestIdentityConverter).Setup(x => x.GetManifestRuleIdentifier(context.ManifestValue, relativeId1)).Returns(manifestId1);
Mock.Get(relativeToManifestIdentityConverter).Setup(x => x.GetManifestRuleIdentifier(context.ManifestValue, relativeId2)).Returns(manifestId2);
Mock.Get(relativeToManifestIdentityConverter).Setup(x => x.GetManifestRuleIdentifier(context.ManifestValue, relativeId3)).Returns(manifestId3);
sut.Dependencies = new[] { relativeId1, relativeId2, relativeId3 };
var result = sut.GetManifestValue().Rules.Single();
Assert.That(result, Has.Property(nameof(ManifestRule.DependencyRules)).EquivalentTo(new[] { manifestId1, manifestId2, manifestId3 }));
}
public void GetManifestRuleIdentifierShouldGetCorrectIdentifierForASiblingRule(RelativeToManifestRuleIdentifierConverter sut,
[ManifestModel] ManifestValue value,
Type ruleType)
{
var expected = new ManifestRuleIdentifier(value, ruleType);
var result = sut.GetManifestRuleIdentifier(value, new RelativeRuleIdentifier(ruleType));
Assert.That(result, Is.EqualTo(expected));
}
static ValidatedValue GetMatchingValidatedValue(ManifestRuleIdentifier dependencyIdentifier, ValidatedValue validatedValue)
{
if (Equals(validatedValue.ManifestValue, dependencyIdentifier.ManifestValue))
{
return(validatedValue);
}
return(validatedValue.ChildValues
.FirstOrDefault(child => Equals(child.ManifestValue, dependencyIdentifier.ManifestValue)));
}
public void GetManifestRuleIdentifierShouldGetCorrectIdentifierForAParentRule(RelativeToManifestRuleIdentifierConverter sut,
[ManifestModel] ManifestValue value,
[ManifestModel] ManifestValue parent,
Type ruleType)
{
value.Parent = parent;
var expected = new ManifestRuleIdentifier(parent, ruleType);
var result = sut.GetManifestRuleIdentifier(value, new RelativeRuleIdentifier(ruleType, ancestorLevels: 1));
Assert.That(result, Is.EqualTo(expected));
}
public void GetManifestRuleIdentifierShouldGetCorrectIdentifierForACousinRuleForAMember(RelativeToManifestRuleIdentifierConverter sut,
[ManifestModel] ManifestValue value,
[ManifestModel] ManifestValue parent,
[ManifestModel] ManifestValue cousin,
Type ruleType,
string memberName)
{
// A "Cousin" rule requires us to descend to the parent manifest
// value, then enter a child based upon a member name
value.Parent = parent;
parent.Children.Add(cousin);
cousin.MemberName = memberName;
var expected = new ManifestRuleIdentifier(cousin, ruleType);
var result = sut.GetManifestRuleIdentifier(value, new RelativeRuleIdentifier(ruleType, memberName, ancestorLevels: 1));
Assert.That(result, Is.EqualTo(expected));
}
public void GetManifestValueShouldHaveARuleAtChildLevelWithTheCorrectDependency([IntegrationTesting] IServiceProvider services)
{
var sut = GetValidatorBuilderForComplexObjectValidator(services);
var manifestValue = sut.GetManifestValue();
var childRule = manifestValue
.Children
.Single(x => x.MemberName == nameof(ComplexObject.Associated))
.Children
.Single(x => x.MemberName != nameof(ComplexObject.StringProperty))
.Rules
.Single();
var expectedManifestValue = manifestValue
.Children
.Single(x => x.MemberName == nameof(ComplexObject.Associated))
.Children
.Single(x => x.MemberName == nameof(ComplexObject.StringProperty));
var expectedIdentifier = new ManifestRuleIdentifier(expectedManifestValue, typeof(StringValueRule));
Assert.That(childRule.DependencyRules, Has.Count.EqualTo(1).And.One.EqualTo(expectedIdentifier));
}
public void ConvertAllRulesAndAddToManifestValuesShouldSuccessfullyConvertTheRuleDependencies([Frozen] IGetsRuleConfiguration configProvider,
[Frozen] IResolvesRuleType ruleTypeResolver,
[Frozen] IGetsManifestRuleIdentifierFromRelativeIdentifier relativeToManifestIdentifierConverter,
ModelRuleToManifestRuleConverter sut,
[ManifestModel] ModelAndManifestValuePair modelAndValue,
[ManifestModel] Rule rule,
Type ruleType,
Action <object> ruleConfig,
RelativeIdentifier dependency1,
RelativeIdentifier dependency2,
Type dependencyType1,
Type dependencyType2,
ManifestRuleIdentifier dependencyId1,
ManifestRuleIdentifier dependencyId2)
{
modelAndValue.ModelValue.Rules.Add(rule);
Mock.Get(ruleTypeResolver).Setup(x => x.GetRuleType(rule.RuleTypeName)).Returns(ruleType);
Mock.Get(configProvider).Setup(x => x.GetRuleConfigurationAction(ruleType, rule.RulePropertyValues)).Returns(ruleConfig);
rule.Dependencies.Add(dependency1);
rule.Dependencies.Add(dependency2);
Mock.Get(ruleTypeResolver).Setup(x => x.GetRuleType(dependency1.RuleTypeName)).Returns(dependencyType1);
Mock.Get(ruleTypeResolver).Setup(x => x.GetRuleType(dependency2.RuleTypeName)).Returns(dependencyType2);
Mock.Get(relativeToManifestIdentifierConverter)
.Setup(x => x.GetManifestRuleIdentifier(modelAndValue.ManifestValue,
It.Is <RelativeRuleIdentifier>(r => r.RuleType == dependencyType1 &&
r.RuleName == dependency1.RuleName &&
r.MemberName == dependency1.MemberName &&
r.AncestorLevels == dependency1.AncestorLevels)))
.Returns(dependencyId1);
Mock.Get(relativeToManifestIdentifierConverter)
.Setup(x => x.GetManifestRuleIdentifier(modelAndValue.ManifestValue,
It.Is <RelativeRuleIdentifier>(r => r.RuleType == dependencyType2 &&
r.RuleName == dependency2.RuleName &&
r.MemberName == dependency2.MemberName &&
r.AncestorLevels == dependency2.AncestorLevels)))
.Returns(dependencyId2);
sut.ConvertAllRulesAndAddToManifestValues(new[] { modelAndValue });
Assert.That(modelAndValue.ManifestValue.Rules.Single().DependencyRules, Is.EquivalentTo(new[] { dependencyId1, dependencyId2 }));
}
public void GetManifestRuleShouldReturnAManifestRuleWithCorrectConfigurationAction([Frozen] IGetsManifestRuleIdentifier identifierFactory,
[Frozen, ManifestModel] ValidatorBuilderContext context,
RuleBuilder <SampleRule> sut,
[ManifestModel] ManifestRuleIdentifier identifier,
string stringPropValue)
{
Mock.Get(identifierFactory)
.Setup(x => x.GetManifestRuleIdentifier(typeof(SampleRule), It.IsAny <ValidatorBuilderContext>(), It.IsAny <string>()))
.Returns(identifier);
sut.ConfigureRule(r => r.StringProp = stringPropValue);
sut.Dependencies.Clear();
var rule = sut.GetManifestValue().Rules.Single();
var sampleRule = new SampleRule();
rule.RuleConfiguration(sampleRule);
Assert.That(sampleRule.StringProp, Is.EqualTo(stringPropValue), "Configuration action applied correctly");
}
public void GetManifestRuleShouldReturnAManifestRulewithCorrectIdentifierFromService([Frozen, ManifestModel] ValidatorBuilderContext context,
[Frozen] IGetsManifestRuleIdentifier identifierFactory,
RuleBuilder <SampleRule> sut,
[ManifestModel] ManifestRuleIdentifier identifier)
{
Mock.Get(identifierFactory)
.Setup(x => x.GetManifestRuleIdentifier(typeof(SampleRule), It.IsAny <ValidatorBuilderContext>(), It.IsAny <string>()))
.Returns(identifier);
Func <object, object> GetFunc(Func <object, object> input) => input;
context.ManifestValue.IdentityAccessor = GetFunc(x => new object());
sut.Dependencies.Clear();
sut.Name = "Rule name";
var rule = sut.GetManifestValue().Rules.Single();
Assert.That(rule.Identifier, Is.SameAs(identifier));
}
