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); }
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 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); }
private Validator <object> GetValidator() { var builder = new ValidatorBuilder <object>(); builder.AddPropertyFilter(_ => true); builder.AddKnownType <TestClass>(); builder.AddEmptyConstraint(); return(builder.Build()); }
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 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 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 EnumerableProperties() { // Arrange var message = Guid.NewGuid().ToString(); var key = Guid.NewGuid().ToString(); var builder = new ValidatorBuilder <object>(); builder.AddKnownType <TestWithEnumerableProperty1>(); builder.AddTypeConstraint <StringItem>((i, ctx) => { if (i.Item is null) { ctx.RaiseError(message); } }, key); var validator = builder.Build(); var context = new TestValidationContext(); var item = new TestWithEnumerableProperty1 { Items = new[] { new StringItem { Item = "1" }, new StringItem { Item = null }, new StringItem { Item = "3" }, }, }; // Act validator.Validate(item, context.Context); // Assert var error = Assert.Single(context.Errors); Assert.Equal(message, error.Message); Assert.Equal(key, error.Id); Assert.Collection(context.Items, i => Assert.Equal(item, i), i => Assert.Equal(item.Items, i), i => Assert.Equal(item.Items[0], i), i => Assert.Equal(item.Items[1], i), i => Assert.Equal(item.Items[2], i)); }
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 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 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 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 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); }
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); }
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); }
internal ValidatorPropertyBuilder(ValidatorBuilder <TState> builder) { _builder = builder; _builder.AddKnownType <TType>(); }