/// <summary>
/// Gets a builder for validating a value of a validated object (typically retrieved via member access).
/// </summary>
/// <typeparam name="TValidated">The type of the primary object under validation.</typeparam>
/// <typeparam name="TValue">The type of the derived value to be validated.</typeparam>
/// <param name="ValidatorBuilderContext">Contextual information about how validation rules should be built.</param>
/// <param name="valueConfig">An action which configures the value accessor-builder.</param>
/// <returns>A builder for validating the derived value.</returns>
public IBuildsValueAccessor <TValidated, TValue> GetValueAccessorBuilder <TValidated, TValue>(ValidatorBuilderContext ValidatorBuilderContext,
Action <IConfiguresValueAccessor <TValidated, TValue> > valueConfig)
{
var builder = new ValueAccessorBuilder <TValidated, TValue>(ValidatorBuilderContext,
ruleBuilderFactory(),
validatorManifestFactory(),
contextFactory());
if (!(valueConfig is null))
{
valueConfig(builder);
}
return(builder);
}
public void AddRulesShouldAddBuilderReturnedFromManifestFactory([Frozen] IGetsValidatorManifest manifestFactory,
[Frozen, ManifestModel] ValidatorBuilderContext context,
ValueAccessorBuilder <ValidatedObject, string> sut,
IGetsManifestValue manifest,
[ManifestModel] ManifestRule rule,
[ManifestModel] ManifestValue value)
{
Mock.Get(manifestFactory)
.Setup(x => x.GetValidatorManifest(typeof(StringValidator), context))
.Returns(manifest);
Mock.Get(manifest).Setup(x => x.GetManifestValue()).Returns(() => value);
sut.AddRules <StringValidator>();
Assert.That(sut.GetManifestValue().Children.Single(), Is.SameAs(value));
}
/// <inheritdoc/>
public IConfiguresValueAccessor <TValidated, TValue> WhenValueIs <TDerived>(Action <IConfiguresValueAccessor <TValidated, TDerived> > derivedConfig)
where TDerived : TValue
{
var derivedContext = builderContextFactory.GetPolymorphicContext(context, typeof(TDerived));
var derivedBuilder = new ValueAccessorBuilder <TValidated, TDerived>(derivedContext,
ruleBuilderFactory,
validatorManifestFactory,
builderContextFactory);
if (!(derivedConfig is null))
{
derivedConfig(derivedBuilder);
}
ruleBuilders.Add(derivedBuilder);
return(this);
}
public void WhenValueIsShouldAddAPolymorphicTypeToTheManifestValue([Frozen] IGetsValidatorBuilderContext contextFactory,
[Frozen, ManifestModel] ValidatorBuilderContext context,
ValueAccessorBuilder <object, ValidatedObject> sut,
[ManifestModel] ManifestPolymorphicType polymorphicType)
{
var derivedContext = new ValidatorBuilderContext(polymorphicType);
Mock.Get(contextFactory).Setup(x => x.GetPolymorphicContext(context, typeof(DerivedValidatedObject))).Returns(derivedContext);
sut.WhenValueIs <DerivedValidatedObject>(c => { });
Assert.Multiple(() =>
{
var manifestValue = sut.GetManifestValue();
Assert.That(manifestValue,
Is.InstanceOf <IHasPolymorphicTypes>(),
"Manifest value has polymorphic types.");
Assert.That(manifestValue,
Has.Property(nameof(IHasPolymorphicTypes.PolymorphicTypes)).One.SameAs(polymorphicType),
"Manifest includes expected polymotphic type");
});
}
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 GetManifestRulesShouldIterateOverEveryRuleAdded([Frozen, ManifestModel] ValidatorBuilderContext context,
[Frozen] IGetsRuleBuilder ruleBuilderFactory,
ValueAccessorBuilder <ValidatedObject, string> sut,
[ManifestModel] ManifestValue value)
{
Mock.Get(ruleBuilderFactory)
.Setup(x => x.GetRuleBuilder <StringValueRule>(It.IsAny <ValidatorBuilderContext>(), It.IsAny <Action <IConfiguresRule <StringValueRule> > >()))
.Returns(() => {
var ruleBuilder = new Mock <IBuildsRule <StringValueRule> >();
ruleBuilder
.Setup(x => x.GetManifestValue())
.Returns(() => value);
return(ruleBuilder.Object);
});
sut.AddRuleWithParent <StringValueRule>();
sut.AddRuleWithParent <StringValueRule>();
var manifestRules = sut.GetManifestValue().Rules.ToList();
Mock.Get(ruleBuilderFactory)
.Verify(x => x.GetRuleBuilder <StringValueRule>(context, It.IsAny <Action <IConfiguresRule <StringValueRule> > >()),
Times.Exactly(2));
}
public void GetManifestValueShouldNotMarkTheManifestValueWithAnExceptionBehaviourIfAccessorExceptionBehaviourWasNotCalled([Frozen, ManifestModel] ValidatorBuilderContext context,
ValueAccessorBuilder <ValidatedObject, string> sut)
{
((ManifestValue)context.ManifestValue).AccessorExceptionBehaviour = null;
Assert.That(() => sut.GetManifestValue(), Has.Property(nameof(ManifestValue.AccessorExceptionBehaviour)).Null);
}
public void AccessorExceptionBehaviourShouldMarkTheManifestValueWithThatBehaviour([Frozen, ManifestModel] ValidatorBuilderContext context,
ValueAccessorBuilder <ValidatedObject, string> sut,
ValueAccessExceptionBehaviour behaviour)
{
((ManifestValue)context.ManifestValue).AccessorExceptionBehaviour = behaviour;
sut.AccessorExceptionBehaviour(behaviour);
Assert.That(() => sut.GetManifestValue(), Has.Property(nameof(ManifestValue.AccessorExceptionBehaviour)).EqualTo(behaviour));
}
