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 TypeConstraintDerived(bool input)
{
var message = Guid.NewGuid().ToString();
var builder = new ValidatorBuilder <object>();
var constraintId = Guid.NewGuid().ToString();
builder.AddTypeConstraint <SimpleBoolean>((c, ctx) =>
{
if (!c.IsTrue)
{
ctx.RaiseError(message);
}
}, constraintId);
var validator = builder.Build();
var context = new TestValidationContext();
validator.Validate(new SimpleBooleanDerived {
IsTrue = input
}, context.Context);
if (input)
{
Assert.Empty(context.Errors);
}
else
{
var error = Assert.Single(context.Errors);
Assert.Equal(constraintId, error.Id);
Assert.Equal(message, error.Message);
}
}
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);
}
public void EnumerablePropertiesWithCycle()
{
// Arrange
var message = Guid.NewGuid().ToString();
var key = Guid.NewGuid().ToString();
var builder = new ValidatorBuilder <object>();
builder.AddTypeConstraint <CyclicEnumerable>((i, ctx) =>
{
if (i.Name is null)
{
ctx.RaiseError(message);
}
}, key);
var validator = builder.Build();
var context = new TestValidationContext();
var item = new CyclicEnumerable {
Name = "0"
};
item.Others = new[]
{
new CyclicEnumerable {
Name = "1", Others = new[] { new CyclicEnumerable {
Name = "2"
} }
},
new CyclicEnumerable {
Name = null, Others = new[] { item }
},
new CyclicEnumerable {
Name = "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.Others, i),
i => Assert.Equal(item.Others[0], i),
i => Assert.Equal(item.Others[1], i),
i => Assert.Equal(item.Others[2], i),
i => Assert.Equal(item.Others[0].Others, i),
i => Assert.Equal(item.Others[0].Others[0], i),
i => Assert.Equal(item.Others[1].Others, i));
}
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 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 ThrowsIfNoConstraints()
{
var builder = new ValidatorBuilder <object>();
builder.AddEmptyClass();
var exception = Assert.Throws <ValidatorBuilderException>(() => builder.Build());
Assert.Equal(Errors.NoConstraintsFound, exception.Id);
Assert.NotNull(exception.Message);
Assert.Null(exception.Property);
Assert.Null(exception.Type);
}
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 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 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 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 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 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 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);
}
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 SimpleProperty()
{
const string Value = "hello!";
var count = 0;
var builder = new ValidatorBuilder <object>();
builder
.ForType <Test1>()
.AddProperty(t => t.Instance);
var test = new Test1
{
Instance = new Test2
{
Member = Value,
},
};
builder.AddConstraint(_ => new DelegateConstraint(value =>
{
if (value is string)
{
Assert.Equal(Value, value);
count++;
}
return(true);
}));
var validator = builder.Build();
var context = new TestValidationContext();
validator.Validate(test, context.Context);
Assert.Equal(1, count);
}
