public void SkipIndexer()
{
var builder = new ValidatorBuilder <object>();
var count = 0;
builder.AddEmptyConstraint(true);
builder.AddKnownType <ClassWithIndexer>();
builder.AddPropertyConstraintFactory((property, _) =>
{
Assert.Empty(property.GetIndexParameters());
count++;
return(null);
});
var validator = builder.Build();
var context = new TestValidationContext();
validator.Validate(new ClassWithIndexer(), context.Context);
Assert.Equal(1, count);
Assert.Empty(context.Errors);
Assert.Empty(context.UnknownTypes);
}
private Validator <object> GetValidator()
{
var builder = new ValidatorBuilder <object>();
builder.AddPropertyFilter(_ => true);
builder.AddKnownType <TestClass>();
builder.AddEmptyConstraint();
return(builder.Build());
}
public void ThrowsOnUnknown()
{
var builder = new ValidatorBuilder <object>();
builder.AddKnownType <int>();
builder.AddEmptyConstraint(true);
var validator = builder.Build();
var exception = Assert.Throws <ValidatorBuilderException>(() => validator.Validate(string.Empty, null));
Assert.Equal(typeof(string), exception.Type);
Assert.Equal(Errors.UnknownType, exception.Id);
Assert.Null(exception.Property);
}
public void BuilderContextIsDisposed()
{
var builder = new ValidatorBuilder <object>();
var context = default(BuilderContext <object>);
builder.AddEmptyConstraint(withType: true);
builder.AddPropertyConstraintFactory((property, ctx) =>
{
context = ctx;
return(null);
});
var validator = builder.Build();
Assert.NotNull(context);
Assert.Throws <ObjectDisposedException>(() => context.GetOrSetState(string.Empty, key => string.Empty));
}
public void DoesNotIncludeNoGetter()
{
var builder = new ValidatorBuilder <object>();
builder.AddKnownType <NoGetter>();
builder.AddEmptyConstraint(true);
builder.AddConstraint(p =>
{
if (p == typeof(NoGetter).GetProperty(nameof(NoGetter.Test)))
{
Assert.False(true, "Should not get here as there is no getter");
}
return(null);
});
Assert.NotNull(builder.Build());
}
public void NoPattern()
{
var builder = new ValidatorBuilder <object>();
builder.AddRegexAttributeConstraint <RegexAttribute>(r => r.Pattern);
builder.AddKnownType <TestNoPattern>();
builder.AddEmptyConstraint();
var validator = builder.Build();
var context = new TestValidationContext();
var item = new TestNoPattern {
Test = "hello"
};
validator.Validate(item, context.Context);
Assert.Empty(context.Errors);
Assert.Single(context.Items);
}
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);
}
public void OverrideThrowsOnUnknown()
{
var count = 0;
var builder = new ValidatorBuilder <object>();
builder.AddEmptyConstraint(true);
builder.AddKnownType <int>();
var validator = builder.Build();
var context = new ValidationContext <object>
{
OnUnknownType = type =>
{
Assert.Equal(typeof(string), type);
count++;
},
};
validator.Validate(string.Empty, context);
Assert.Equal(1, count);
}
public void StaticProperty()
{
var builder = new ValidatorBuilder <object>();
var count = 0;
builder.AddEmptyConstraint(true);
builder.AddKnownType <StaticPropertyBoolean>();
builder.AddPropertyConstraintFactory((property, _) =>
{
count++;
Assert.NotEqual(typeof(StaticPropertyBoolean).GetProperty(nameof(StaticPropertyBoolean.Test)), property);
return(null);
});
var validator = builder.Build();
var context = new TestValidationContext();
validator.Validate(new StaticPropertyBoolean(), context.Context);
Assert.Equal(1, count);
Assert.Empty(context.Errors);
Assert.Empty(context.UnknownTypes);
}
