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 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 GetContextForValueShouldReturnContextWithoutMemberName([ManifestModel] ValidatorBuilderContext validationContext,
ValidatorBuilderContextFactory sut)
{
var result = sut.GetContextForValue <ValidatedObject, string>(v => v.AProperty, validationContext);
Assert.That(result.ManifestValue, Has.Property(nameof(ManifestValue.MemberName)).Null);
}
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 ValidatorBuilderContext GetPolymorphicContext(ValidatorBuilderContext validatorContext, Type derivedType)
{
if (validatorContext is null)
{
throw new ArgumentNullException(nameof(validatorContext));
}
if (derivedType is null)
{
throw new ArgumentNullException(nameof(derivedType));
}
if (!(validatorContext.ManifestValue is IHasPolymorphicTypes polyManifest))
{
var message = String.Format(Resources.ExceptionMessages.GetExceptionMessage("MustImplementPolymorphicInterface"),
typeof(IHasPolymorphicTypes).Name,
validatorContext.ManifestValue?.GetType().FullName ?? "<null>");
throw new ArgumentException(message, nameof(validatorContext));
}
ManifestPolymorphicType existingPoly;
if ((existingPoly = polyManifest.PolymorphicTypes.FirstOrDefault(x => x.ValidatedType == derivedType)) != null)
{
return(new ValidatorBuilderContext(existingPoly));
}
var polymorphicValue = new ManifestPolymorphicType
{
Parent = validatorContext.ManifestValue.Parent,
ValidatedType = derivedType,
};
polyManifest.PolymorphicTypes.Add(polymorphicValue);
return(new ValidatorBuilderContext(polymorphicValue));
}
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 void GetContextForValueShouldReturnContextWithCorrectAccessor([ManifestModel] ValidatorBuilderContext validationContext,
ValidatorBuilderContextFactory sut,
ValidatedObject obj)
{
var result = sut.GetContextForValue <ValidatedObject, string>(v => v.AProperty, validationContext);
Assert.That(() => ((ManifestValue)result.ManifestValue).AccessorFromParent(obj), Is.EqualTo(obj.AProperty));
}
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);
}
public void GetPolymorphicContextShouldThrowIfManifestValueCannotHavePolymorphicTypes([ManifestModel] ManifestPolymorphicType manifestModel,
ValidatorBuilderContextFactory sut)
{
var validationContext = new ValidatorBuilderContext(manifestModel);
Assert.That(() => sut.GetPolymorphicContext(validationContext, typeof(object)),
Throws.ArgumentException.And.Message.StartWith("The validation manifest value for the current context must implement IHasPolymorphicTypes"));
}
public void UseObjectIdentityShouldAddIdentityAccessorToTheContext([Frozen, ManifestModel] ValidatorBuilderContext context,
ValidatorBuilder <ValidatedObject> sut,
ValidatedObject obj)
{
sut.UseObjectIdentity(x => x.Identity);
Assert.That(() => context.ManifestValue.IdentityAccessor(obj), Is.EqualTo(obj.Identity));
}
/// <summary>
/// Gets an object which provides manifest rules from a specified validator-builder type.
/// </summary>
/// <param name="definitionType">A type which must implement <see cref="IBuildsValidator{TValidated}"/>.</param>
/// <param name="context">Contextual information about how a validator should be built.</param>
/// <returns>An object which provides a collection of <see cref="Manifest.ManifestRule"/> instances.</returns>
/// <exception cref="ArgumentException">If the <paramref name="definitionType"/> does not implement <see cref="IBuildsValidator{TValidated}"/>.</exception>
public IGetsManifestValue GetValidatorManifest(Type definitionType, ValidatorBuilderContext context)
{
var validatedType = GetValidatedType(definitionType);
var method = getValidatorManifestGenericMethod.MakeGenericMethod(validatedType);
return((IGetsManifestValue)method.Invoke(this, new object[] { definitionType, context }));
}
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);
}
IGetsManifestValue GetValidatorManifestGeneric <T>(Type definitionType, ValidatorBuilderContext context)
{
var definition = GetValidatorBuilder <T>(definitionType);
var builder = new ValidatorBuilder <T>(RuleContextFactory, RuleBuilderFactory, ValueBuilderFactory, ValidatorManifestFactory, context);
definition.ConfigureValidator(builder);
return(builder);
}
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);
}
public void GetPolymorphicContextShouldReturnANewContextIfAnExistingPolymorphicTypeDoesNotExist([ManifestModel] ManifestValue manifestValue,
ValidatorBuilderContextFactory sut)
{
manifestValue.PolymorphicTypes.Clear();
var validationContext = new ValidatorBuilderContext(manifestValue);
Assert.That(() => sut.GetPolymorphicContext(validationContext, typeof(string))?.ManifestValue,
Is.InstanceOf <ManifestPolymorphicType>());
}
public void GetValueAccessorBuilderShouldReturnAnAccessorBuilder([ManifestModel] ValidatorBuilderContext context,
IGetsRuleBuilder ruleBuilderFactory,
IGetsValidatorManifest validatorManifestFactory,
IGetsValidatorBuilderContext contextFactory)
{
var sut = new ValueAccessorBuilderFactory(() => ruleBuilderFactory, () => validatorManifestFactory, () => contextFactory);
Assert.That(() => sut.GetValueAccessorBuilder <ValidatedObject, string>(context, c => { }), Is.Not.Null);
}
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));
}
/// <summary>
/// Gets the validator builder object, optionally for a specified validator builder context.
/// </summary>
/// <typeparam name="TValidated">The type of object to be validated.</typeparam>
/// <param name="context">An optional validator builder context; if <see langword="null"/> then a new/empty context will be created.</param>
/// <returns>A validator builder.</returns>
public IValidatorBuilder <TValidated> GetValidatorBuilder <TValidated>(ValidatorBuilderContext context = null)
{
var builderContext = context ?? CreateEmptyContext(typeof(TValidated));
return(new ValidatorBuilder <TValidated>(ruleContextFactory(),
ruleBuilderFactory(),
valueBuilderFactory(),
validatorManifestFactory(),
builderContext));
}
/// <summary>
/// Initializes a new instance of <see cref="ValueAccessorBuilder{TValidated, TValue}"/>.
/// </summary>
/// <param name="context">The context which should be used for newly-added rule-builders.</param>
/// <param name="ruleBuilderFactory">A factory for rule-builder instances.</param>
/// <param name="validatorManifestFactory">A factory for validator manifest instances.</param>
/// <param name="builderContextFactory">A factory for validator builder contexts.</param>
public ValueAccessorBuilder(ValidatorBuilderContext context,
IGetsRuleBuilder ruleBuilderFactory,
IGetsValidatorManifest validatorManifestFactory,
IGetsValidatorBuilderContext builderContextFactory)
{
this.validatorManifestFactory = validatorManifestFactory ?? throw new ArgumentNullException(nameof(validatorManifestFactory));
this.builderContextFactory = builderContextFactory ?? throw new ArgumentNullException(nameof(builderContextFactory));
this.context = context ?? throw new ArgumentNullException(nameof(context));
this.ruleBuilderFactory = ruleBuilderFactory ?? throw new ArgumentNullException(nameof(ruleBuilderFactory));
}
/// <summary>
/// Gets a rule builder instance from the specified context and rule-definition action.
/// </summary>
/// <typeparam name="TRule">The type of object which the rule validates.</typeparam>
/// <param name="context">Contextual information from which to build this rule.</param>
/// <param name="ruleDefinition">An optional configuration/definition action which will be used to customise the rule.</param>
/// <returns>A rule builder object.</returns>
public IBuildsRule <TRule> GetRuleBuilder <TRule>(ValidatorBuilderContext context, Action <IConfiguresRule <TRule> > ruleDefinition)
{
var builder = new RuleBuilder <TRule>(context, manifestIdentifierConverter(), manifestIdentifierFactory());
if (!(ruleDefinition is null))
{
ruleDefinition(builder);
}
return(builder);
}
public void GetPolymorphicContextShouldReturnAContextFromAnExistingPolymorphicTypeIfItExists([ManifestModel] ManifestPolymorphicType polymorphicValue,
[ManifestModel] ManifestValue manifestValue,
ValidatorBuilderContextFactory sut)
{
manifestValue.PolymorphicTypes.Add(polymorphicValue);
polymorphicValue.ValidatedType = typeof(string);
var validationContext = new ValidatorBuilderContext(manifestValue);
Assert.That(() => sut.GetPolymorphicContext(validationContext, typeof(string))?.ManifestValue,
Is.SameAs(polymorphicValue));
}
public void GetValueAccessorBuilderShouldExecuteConfigurationUponBuilder([ManifestModel] ValidatorBuilderContext context,
IGetsRuleBuilder ruleBuilderFactory,
IGetsValidatorManifest validatorManifestFactory,
IGetsValidatorBuilderContext contextFactory)
{
var sut = new ValueAccessorBuilderFactory(() => ruleBuilderFactory, () => validatorManifestFactory, () => contextFactory);
sut.GetValueAccessorBuilder <ValidatedObject, string>(context, c => c.AddRuleWithParent <StringValueRule>());
Mock.Get(ruleBuilderFactory)
.Verify(x => x.GetRuleBuilder <StringValueRule>(context, It.IsAny <Action <IConfiguresRule <StringValueRule> > >()), Times.Once);
}
public void GetContextForMemberShouldReturnContextWithMemberName([Frozen] IStaticallyReflects reflect,
[ManifestModel] ValidatorBuilderContext validationContext,
ValidatorBuilderContextFactory sut)
{
Mock.Get(reflect)
.Setup(x => x.Member(It.IsAny <Expression <Func <ValidatedObject, string> > >()))
.Returns((Expression <Func <ValidatedObject, string> > accessor) => Reflect.Member(accessor));
var result = sut.GetContextForMember <ValidatedObject, string>(v => v.AProperty, validationContext);
Assert.That(result.ManifestValue, Has.Property(nameof(ManifestValue.MemberName)).EqualTo(nameof(ValidatedObject.AProperty)));
}
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));
}
ValidatorBuilderContext GetCollectionItemContext(ValidatorBuilderContext parentContext, Type validatedType)
{
if (parentContext.ManifestValue.CollectionItemValue != null)
{
return(new ValidatorBuilderContext(parentContext.ManifestValue.CollectionItemValue));
}
var manifestValue = new ManifestCollectionItem
{
Parent = parentContext.ManifestValue,
ValidatedType = validatedType,
};
parentContext.ManifestValue.CollectionItemValue = manifestValue;
return(new ValidatorBuilderContext(manifestValue));
}
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 GetValidatorManifestWithRuleContextShouldReturnAValidatorBuilder([Frozen] IServiceProvider serviceProvider,
ImportedValidatorBuilderManifestFactory sut,
IGetsValidatorBuilderContext ruleContextFactory,
IGetsRuleBuilder ruleBuilderFactory,
IGetsValueAccessorBuilder valueBuilderFactory,
IGetsValidatorManifest validatorManifestFactory,
IResolvesServices resolver,
[ManifestModel] ValidatorBuilderContext context)
{
Mock.Get(serviceProvider).Setup(x => x.GetService(typeof(IGetsValidatorBuilderContext))).Returns(ruleContextFactory);
Mock.Get(serviceProvider).Setup(x => x.GetService(typeof(IGetsRuleBuilder))).Returns(ruleBuilderFactory);
Mock.Get(serviceProvider).Setup(x => x.GetService(typeof(IGetsValueAccessorBuilder))).Returns(valueBuilderFactory);
Mock.Get(serviceProvider).Setup(x => x.GetService(typeof(IGetsValidatorManifest))).Returns(validatorManifestFactory);
Mock.Get(serviceProvider).Setup(x => x.GetService(typeof(IResolvesServices))).Returns(resolver);
Mock.Get(resolver).Setup(x => x.ResolveService <object>(typeof(GenericValidatorDefinition <object>))).Returns(() => new GenericValidatorDefinition <object>());
var result = sut.GetValidatorManifest(typeof(GenericValidatorDefinition <object>), context);
Assert.That(result, Is.InstanceOf <ValidatorBuilder <object> >());
}
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 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 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");
});
}
