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 ValidateCancelTest()
#if NO_CANCELLATION_TOKEN
{
var context = new TestValidationContext();
Assert.False(context.Context.IsCancelled);
// Must use a type with multiple types as cancellation is checked at the start of processing each type
var validator = ValidatorBuilder.Create()
.AddKnownType <TestClass1>()
.AddPropertyFilter <TestClass2>()
.AddConstraint(_ => new DelegateConstraint(() =>
{
context.Context.Cancel();
}))
.Build();
var instance = new TestClass1
{
Instance = new TestClass2(),
};
Assert.Throws <OperationCanceledException>(() => validator.Validate(instance, context.Context));
Assert.True(context.Context.IsCancelled);
}
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 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));
}
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 TwoInstances()
{
var instance = new TestClass
{
Value = new TestClass(),
};
var context = new TestValidationContext();
GetValidator().Validate(instance, context.Context);
Assert.Empty(context.Errors);
Assert.Equal(2, context.Items.Count);
}
public void SingleInstance()
{
var instance = new TestClass
{
};
var context = new TestValidationContext();
GetValidator().Validate(instance, context.Context);
Assert.Empty(context.Errors);
Assert.Single(context.Items);
}
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 MultipleInstanceWithCycle()
{
var instance1 = new TestClass();
var instance = new TestClass
{
Value = instance1,
};
instance1.Value = instance;
var context = new TestValidationContext();
GetValidator().Validate(instance, context.Context);
Assert.Empty(context.Errors);
Assert.Equal(2, context.Items.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 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 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);
}
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);
}