public void SimplePatternTests(string testValue, bool isError)
{
var builder = new ValidatorBuilder <object>();
builder.AddRegexAttributeConstraint <RegexAttribute>(r => r.Pattern);
builder.AddKnownType <Test1>();
var validator = builder.Build();
var item = new Test1 {
Test = testValue
};
var issueRaised = 0;
var context = new ValidationContext <object>
{
OnError = error =>
{
Assert.True(isError);
Assert.IsType <Regex>(error.Context);
Assert.Equal("he.*lo", error.Context.ToString(), StringComparer.Ordinal);
Assert.Equal(testValue, (string)error.Value, StringComparer.Ordinal);
Assert.Same(item, error.Instance);
issueRaised++;
},
};
validator.Validate(item, context);
var expectedCount = isError ? 1 : 0;
Assert.Equal(expectedCount, issueRaised);
}
public void PatternNoObserverNotStringWithMapper()
{
const string Value = "here";
var builder = new ValidatorBuilder <object>();
builder.AddRegexAttributeConstraint <RegexAttribute>(r => r.Pattern)
.AddTypeMapper <int>(i => Value);
builder.AddKnownType <TestNotString>();
var validator = builder.Build();
var item = new TestNotString();
var issueRaised = 0;
var context = new ValidationContext <object>
{
OnError = error =>
{
Assert.IsType <Regex>(error.Context);
Assert.Equal("he.*lo", error.Context.ToString(), StringComparer.Ordinal);
Assert.Equal(Value, (string)error.Value, StringComparer.Ordinal);
Assert.Same(item, error.Instance);
issueRaised++;
},
};
validator.Validate(item, context);
Assert.Equal(1, issueRaised);
}
public void PatternNoObserverNotString()
{
var builder = new ValidatorBuilder <object>();
builder.AddRegexAttributeConstraint <RegexAttribute>(r => r.Pattern);
builder.AddKnownType <TestNotString>();
var exp = Assert.Throws <ValidatorBuilderException>(() => builder.Build());
Assert.Equal(Errors.UnsupportedTypeForConstraint, exp.Id);
Assert.Equal(typeof(TestNotString), exp.Type);
Assert.Equal(typeof(TestNotString).GetProperty(nameof(TestNotString.Other)), exp.Property);
}
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 SamePatternIsCached()
{
var builder = new ValidatorBuilder <object>();
builder.AddRegexAttributeConstraint <RegexAttribute>(r => r.Pattern);
builder.AddKnownType <DuplicatePattern>();
var validator = builder.Build();
var instance = new DuplicatePattern();
var context = new TestValidationContext();
validator.Validate(instance, context.Context);
Assert.Equal(2, context.Errors.Count);
var error1 = Assert.IsType <Regex>(context.Errors[0].Context);
var error2 = Assert.IsType <Regex>(context.Errors[1].Context);
Assert.Same(error1, error2);
}
public void PatternNoObserver()
{
var builder = new ValidatorBuilder <object>();
builder.AddRegexAttributeConstraint <RegexAttribute>(r => r.Pattern);
builder.AddKnownType <Test1>();
var validator = builder.Build();
var item = new Test1();
var items = new List <object>();
var context = new ValidationContext <object>
{
OnItem = items.Add,
};
var exception = Assert.Throws <ValidationException>(() => validator.Validate(item, context));
Assert.Equal(item, exception.Error.Instance);
Assert.Equal(typeof(Test1).GetProperty(nameof(Test1.Test)), exception.Error.Property);
var single = Assert.Single(items);
Assert.Same(item, single);
}
/// <summary>
/// Add a regular expression constraint using <see cref="RegularExpressionAttribute"/>.
/// </summary>
/// <param name="builder">The current <see cref="ValidatorBuilder{TState}"/>.</param>
/// <typeparam name="TState">Custom type supplied for the validation.</typeparam>
/// <returns>A constraint builder instance.</returns>
public static ConstraintBuilder <TState, string> AddRegexAttributeConstraint <TState>(this ValidatorBuilder <TState> builder)
{
return(builder
.AddRegexAttributeConstraint <RegularExpressionAttribute>(pattern => pattern.Pattern));
}
