private Validator <object> GetValidator()
{
var builder = new ValidatorBuilder <object>();
builder.AddPropertyFilter(_ => true);
builder.AddKnownType <TestClass>();
builder.AddEmptyConstraint();
return(builder.Build());
}
/// <summary>
/// Add a property filter to <see cref="ValidatorBuilder{TOptions}"/> for <typeparamref name="TProperty"/>.
/// </summary>
/// <typeparam name="TProperty">Property to add a filter for.</typeparam>
/// <param name="memberExpression">Expression to identify the property.</param>
/// <returns>The current <see cref="ValidatorPropertyBuilder{TType, TState}"/>.</returns>
public ValidatorPropertyBuilder <TType, TState> AddProperty <TProperty>(Expression <Func <TType, TProperty> > memberExpression)
{
if (memberExpression.Body is MemberExpression member && member.Member is PropertyInfo property)
{
_builder.AddPropertyFilter(p => p == property);
return(this);
}
throw new InvalidOperationException(SR.ExpressionPropertyRequired);
}
public async Task AsyncValidation()
{
const int ParallelCount = 2;
var list = new HashSet <int>();
var cts = new CancellationTokenSource();
var builder = new ValidatorBuilder <object>();
builder.AddKnownType <RecursiveClass>();
builder.AddPropertyFilter <RecursiveClass>();
builder.AddConstraint(_ => new DelegateConstraint(instanceValue =>
{
lock (list)
{
if (Task.CurrentId.HasValue)
{
list.Add(Task.CurrentId.Value);
}
}
return(true);
}));
var validator = builder.Build();
var instance = new RecursiveClass
{
Entry1 = new RecursiveClass
{
Entry1 = new RecursiveClass
{
},
Entry2 = new RecursiveClass
{
},
},
Entry2 = new RecursiveClass
{
Entry1 = new RecursiveClass
{
},
Entry2 = new RecursiveClass
{
},
},
};
var context = new TestValidationContext();
context.Context.MaxDegreeOfParallelism = ParallelCount;
await validator.ValidateAsync(instance, context.Context).ConfigureAwait(false);
Assert.Equal(ParallelCount, list.Count);
}
public void TestStruct()
{
var count = 0;
var builder = new ValidatorBuilder <object>();
builder.AddKnownType <CustomStruct>();
builder.AddPropertyFilter(_ => true);
builder.AddConstraint(_ => new DelegateConstraint(() =>
{
count++;
return(true);
}));
var validator = builder.Build();
validator.Validate(default(CustomStruct), null);
Assert.Equal(1, count);
}
public void AbstractPropertyTest()
{
var count = 0;
var builder = new ValidatorBuilder <object>();
builder.AddKnownType <TestWithAbstractProperty>();
builder.AddPropertyFilter <TestWithAbstractProperty>();
builder.AddConstraint(_ => new DelegateConstraint(instanceValue =>
{
var value = Assert.IsType <string>(instanceValue);
Assert.Equal(nameof(TestWithDerivedAbstractProperty), value);
count++;
return(true);
}));
var validator = builder.Build();
validator.Validate(new TestWithDerivedAbstractProperty(), null);
Assert.Equal(1, count);
}
public void RecursiveDescentBySubtype()
{
var instance1 = new TestClass();
var instance = new TestClass
{
Value = instance1,
};
instance1.Value = instance;
var builder = new ValidatorBuilder <object>();
builder.AddKnownType <TestClass>();
builder.AddPropertyFilter <TestClassBase>();
builder.AddEmptyConstraint();
var validator = builder.Build();
var context = new TestValidationContext();
validator.Validate(instance, context.Context);
Assert.Empty(context.Errors);
Assert.Equal(2, context.Items.Count);
}
