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 GetRuleBuilderShouldReturnBuilder(IGetsManifestRuleIdentifierFromRelativeIdentifier identifierConverter,
IGetsManifestRuleIdentifier identifierFactory,
[ManifestModel] ValidatorBuilderContext context)
{
var sut = new RuleBuilderFactory(() => identifierConverter, () => identifierFactory);
Assert.That(() => sut.GetRuleBuilder <ObjectRule>(context, c => { }), Is.Not.Null);
}
/// <summary>
/// Initialises an instance of <see cref="ModelRuleToManifestRuleConverter"/>.
/// </summary>
/// <param name="configProvider">A rule-configuration provider.</param>
/// <param name="ruleTypeResolver">A rule-type resolver.</param>
/// <param name="relativeToManifestIdentifierConverter">A converter which turns relative identifiers into manifest identifiers.</param>
public ModelRuleToManifestRuleConverter(IGetsRuleConfiguration configProvider,
IResolvesRuleType ruleTypeResolver,
IGetsManifestRuleIdentifierFromRelativeIdentifier relativeToManifestIdentifierConverter)
{
this.configProvider = configProvider ?? throw new ArgumentNullException(nameof(configProvider));
this.ruleTypeResolver = ruleTypeResolver ?? throw new ArgumentNullException(nameof(ruleTypeResolver));
this.relativeToManifestIdentifierConverter = relativeToManifestIdentifierConverter ?? throw new ArgumentNullException(nameof(relativeToManifestIdentifierConverter));
}
public void GetRuleBuilderShouldExecuteConfigurationUponBuilder(IGetsManifestRuleIdentifierFromRelativeIdentifier identifierConverter,
IGetsManifestRuleIdentifier identifierFactory,
[ManifestModel] ValidatorBuilderContext context,
string name)
{
var sut = new RuleBuilderFactory(() => identifierConverter, () => identifierFactory);
var result = sut.GetRuleBuilder <ObjectRule>(context, c => c.Name = name);
Assert.That(result.Name, Is.EqualTo(name));
}
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 }));
}
