public void Should_ThrowException_When_NullContext()
{
var rule = new AsRelativeRule <object>(c => true, new Error("message"));
Assert.Throws <ArgumentNullException>(() =>
{
rule.TryGetErrors(new object(),
null,
ValidationStrategy.Complete,
out _);
});
}
public void Should_AddError_When_Valid_And_Force()
{
Predicate <object> isValid = m => true;
var error = new Error("message");
var rule = new AsRelativeRule <object>(isValid, error);
var getErrorsResult = rule.TryGetErrors(new object(),
new ExecutionContextStub(),
ValidationStrategy.Force,
out var errorsCollection);
Assert.True(getErrorsResult);
Assert.Same(error, errorsCollection.Errors.Single());
}
public void Should_NotAddError_When_Valid(ValidationStrategy validationStrategy)
{
Predicate <object> isValid = m => true;
var error = new Error("message");
var rule = new AsRelativeRule <object>(isValid, error);
rule.TryGetErrors(new object(),
new ExecutionContextStub(),
validationStrategy,
out var errorsCollection);
Assert.Same(ErrorsCollection.Empty, errorsCollection);
Assert.True(errorsCollection.IsEmpty);
}
public void Should_AddRule_MultipleRules()
{
var memberValidator = new MemberValidator();
var rule1 = new ValidRule<int>(c => true);
var rule2 = new AsRelativeRule<object>(c => true);
var rule3 = new AsModelRule<object>();
memberValidator.AddRule(rule1);
memberValidator.AddRule(rule2);
memberValidator.AddRule(rule3);
Assert.Equal(3, memberValidator.Rules.Count);
Assert.Same(rule1, memberValidator.Rules.ElementAt(0));
Assert.Same(rule2, memberValidator.Rules.ElementAt(1));
Assert.Same(rule3, memberValidator.Rules.ElementAt(2));
}
public void Should_AddError_When_Invalid(ValidationStrategy validationStrategy)
{
Predicate <object> isValid = m => false;
var error = new Error("message");
var rule = new AsRelativeRule <object>(isValid, error);
rule.RuleSingleError = new Error("ruleSingleError");
var getErrorsResult = rule.TryGetErrors(new object(),
new ExecutionContextStub(),
validationStrategy,
out var errorsCollection);
Assert.True(getErrorsResult);
Assert.Same("ruleSingleError", errorsCollection.Errors.Single().Message);
}
public void Should_AddDefaultError_When_Invalid_And_NoError(ValidationStrategy validationStrategy)
{
Predicate <object> isValid = m => false;
var error = new Error("default error {arg}", new[] { Arg.Text("key", "value") });
var rule = new AsRelativeRule <object>(isValid);
var getErrorsResult = rule.TryGetErrors(new object(),
new ExecutionContextStub
{
DefaultError = error
},
validationStrategy,
out var errorsCollection);
Assert.True(getErrorsResult);
Assert.Same(error, errorsCollection.Errors.Single());
}
public void Should_NotExecutePredicate_When_Force()
{
var executed = 0;
Predicate <object> isValid = m =>
{
executed++;
return(true);
};
var rule = new AsRelativeRule <object>(isValid);
rule.TryGetErrors(new object(),
new ExecutionContextStub(),
ValidationStrategy.Force,
out _);
Assert.Equal(0, executed);
}
public void Should_ExecutePredicate(ValidationStrategy validationStrategy)
{
var executed = 0;
Predicate <object> isValid = m =>
{
executed++;
return(true);
};
var rule = new AsRelativeRule <object>(isValid);
rule.TryGetErrors(new object(),
new ExecutionContextStub(),
validationStrategy,
out _);
Assert.Equal(1, executed);
}
public void Should_PassReferenceToPredicate(ValidationStrategy validationStrategy)
{
var executed = false;
var member = new object();
Predicate <object> isValid = m =>
{
executed = true;
Assert.Same(member, m);
return(true);
};
var rule = new AsRelativeRule <object>(isValid);
rule.TryGetErrors(member,
new ExecutionContextStub(),
validationStrategy,
out _);
Assert.True(executed);
}
