public void ShouldNotEqual()
{
var exp1 = EquatableExpression.Create <ClassA, int>(a => a.A);
var exp2 = EquatableExpression.Create <AnotherClassA, int>(a => a.A);
Assert.AreNotEqual(exp1, exp2);
Assert.IsTrue(exp1 != exp2);
Assert.IsFalse(exp1 == exp2);
}
public MessageEntry(Type type, EquatableExpression expression, IRule rule, Func<string> message)
{
//Type cannot be null, others can however.
if (type == null) throw new System.ArgumentNullException("type");
_type = type;
_expression = expression;
_rule = rule;
_message = message;
}
public void ShouldMatchAnyExpression()
{
var r = CreateReport();
var o = new ClassA();
//Simulate an error occuring on ClassA
r.AddError(new ValidationError(CreateRule(), EquatableExpression.Create <ClassA, int>(a => a.A), new object[0], o));
//Passing in null should match any errors on any expressions...
Assert.IsTrue(r.HasError(o, null));
}
public void ShouldValidateAllItemsInEnumeration()
{
var member1 = new Member(null);
var member2 = new Member(null);
var club = new Club(new Member("president"), member1, member2);
var report = new ValidationReport();
_en1.Validate(club, report, ValidationReportDepth.FieldShortCircuit);
var memberNameExp = new EquatableExpression(ExpressionHelper.New<Member, string>(mm => mm.Name));
Assert.IsTrue(report.HasError(member1, memberNameExp), "Expected validation failure for member1. Name was null...");
Assert.IsTrue(report.HasError(member2, memberNameExp), "Expected validation failure for member2. Name was null...");
}
public void ShouldHaveErrorB1()
{
var r = CreateReport();
var o = new ClassB();
//Simulate an error occuring on ClassB.
r.AddError(new ValidationError(CreateRule(), EquatableExpression.Create <ClassB, int>(a => a.A), new object[0], o));
Assert.IsTrue(r.HasError(o, EquatableExpression.Create <ClassA, int>(a => a.A)));
//Eventhough, o is not ClassB, the expression b => b.A still applies to a ClassA. And therefore the following statement must be true.
Assert.IsTrue(r.HasError(o, EquatableExpression.Create <ClassB, int>(b => b.A)));
}
public void ShouldNotApplyTo()
{
var exp1 = EquatableExpression.Create <ClassA, int>(a => a.A);
var exp2 = EquatableExpression.Create <AnotherClassA, int>(a => a.A);
var exp3 = EquatableExpression.Create <ClassB, int>(a => a.B);
Assert.IsFalse(exp1.AppliesTo(exp2));
Assert.IsFalse(exp1.AppliesTo(exp3));
Assert.IsFalse(exp2.AppliesTo(exp1));
Assert.IsFalse(exp2.AppliesTo(exp3));
Assert.IsFalse(exp3.AppliesTo(exp1));
Assert.IsFalse(exp3.AppliesTo(exp2));
}
public void ShouldApplyTo()
{
var exp1 = EquatableExpression.Create <ClassA, int>(a => a.A);
var exp2 = EquatableExpression.Create <ClassB, int>(a1 => a1.A);
var exp3 = EquatableExpression.Create <IClassA, int>(x1 => x1.A);
Assert.IsTrue(exp1.AppliesTo(exp2));
Assert.IsTrue(exp1.AppliesTo(exp3));
Assert.IsTrue(exp2.AppliesTo(exp1));
Assert.IsTrue(exp2.AppliesTo(exp3));
Assert.IsTrue(exp3.AppliesTo(exp1));
Assert.IsTrue(exp3.AppliesTo(exp2));
}
public ValidationError(IRule rule, EquatableExpression expression, object[] validationArguments, object value, object originatingValue, EquatableExpression originatingExpression)
{
if (validationArguments == null) throw new System.ArgumentNullException("validationArguments");
if (value == null) throw new System.ArgumentNullException("value");
if (expression == null) throw new System.ArgumentNullException("cachedExpression");
if (rule == null) throw new System.ArgumentNullException("rule");
_rule = rule;
_expression = expression;
_validationArguments = validationArguments;
_value = value;
_originatingValue = originatingValue;
_originatingExpression = originatingExpression;
}
public void AssertError <T, R>(T value, Expression <Func <T, R> > expression, string ruleKind, params object[] validationArguments)
{
var cachedExp = new EquatableExpression(expression);
var hasError = _errors.Any(e => e.Expression == cachedExp &&
e.Rule.RuleKind == ruleKind &&
object.ReferenceEquals(e.Value, value) &&
AreEquivalent(e.ValidationArguments, validationArguments)
);
if (!hasError)
{
throw new AssertFailedException(string.Format("Expected rule failure for rulekind {0}, expression {1}.", ruleKind, expression));
}
}
public void ShouldValidateAllItemsInEnumeration()
{
var member1 = new Member(null);
var member2 = new Member(null);
var club = new Club(new Member("president"), member1, member2);
var report = new ValidationReport();
_en1.Validate(club, report, ValidationReportDepth.FieldShortCircuit);
var memberNameExp = new EquatableExpression(ExpressionHelper.New <Member, string>(mm => mm.Name));
Assert.IsTrue(report.HasError(member1, memberNameExp), "Expected validation failure for member1. Name was null...");
Assert.IsTrue(report.HasError(member2, memberNameExp), "Expected validation failure for member2. Name was null...");
}
public string GetErrorMessage(Type type, EquatableExpression expression, IRule rule, object[] arguments)
{
var entry = GetEntry(type, rule, expression);
if (entry == null)
{
foreach (Type baseType in GetTypeHierarchy(type))
{
entry = GetEntry(baseType, rule, expression);
if (entry != null) break;
}
}
if (entry == null) return null;
return FormatMessage(entry.Message(), arguments);
}
public void ShouldSkipValidationWhenShortCircuiting()
{
var president = new Member(null);
var club = new Club(president);
var report = new ValidationReport();
var memberNameExp = new EquatableExpression(ExpressionHelper.New <Member, string>(mm => mm.Name));
var presidentExp = new EquatableExpression(ExpressionHelper.New <Club, Member>(cc => cc.President));
//Report an error on the President expression...
report.AddError(new ValidationError(new EqualRule <int>(2), presidentExp, new object[0], club));
_en1.Validate(club, report, ValidationReportDepth.FieldShortCircuit);
//because an error has already been reported on the club's president, the member's name rule would not have been invoked
Assert.IsFalse(report.HasError(president, memberNameExp));
//Now try this again without short-circuiting
_en1.Validate(club, report, ValidationReportDepth.All);
Assert.IsTrue(report.HasError(president, memberNameExp));
}
protected virtual MessageEntry GetEntry(Type type, IRule rule, EquatableExpression expression)
{
var entries = _messageEntries.ToArray();
//entries = entries.Where(e => e.Type.IsAssignableFrom(validationError.Value.GetType())).ToArray();
entries = entries.Where(e => e.Type == type).ToArray();
if (entries.Length == 0) return null;
var entriesByExpression = entries.Where(e => expression == null || expression.AppliesTo(e.Expression)).ToArray();
if (entriesByExpression.Length == 0)
{
entriesByExpression = entries.Where(e => e.Expression == null).ToArray();
if (entriesByExpression.Length == 0) return null;
}
var entriesByRule = entriesByExpression.Where(e => object.ReferenceEquals(e.Rule, rule)).ToArray();
if (entriesByRule.Length == 0)
{
entriesByRule = entriesByExpression.Where(e => object.ReferenceEquals(e.Rule, null)).ToArray();
if (entriesByRule.Length == 0) return null;
}
return entriesByRule.Last();
}
public bool HasError(object value, EquatableExpression expression)
{
return(_innerReport.HasError(value, expression));
}
public bool HasError(object value, EquatableExpression expression)
{
return(_errors.Any(e => e.Expression == expression && object.ReferenceEquals(e.Value, value)));
}
public string GetErrorMessage(object value, EquatableExpression expression, IErrorResolver resolver)
{
throw new NotImplementedException();
}
public void ShouldSkipValidationWhenShortCircuiting()
{
var president = new Member(null);
var club = new Club(president);
var report = new ValidationReport();
var memberNameExp = new EquatableExpression(ExpressionHelper.New<Member, string>(mm => mm.Name));
var presidentExp = new EquatableExpression(ExpressionHelper.New<Club, Member>(cc => cc.President));
//Report an error on the President expression...
report.AddError(new ValidationError(new EqualRule<int>(2), presidentExp, new object[0], club, club, presidentExp));
_en1.Validate(club, report, ValidationReportDepth.FieldShortCircuit);
//because an error has already been reported on the club's president, the member's name rule would not have been invoked
Assert.IsFalse(report.HasError(president, memberNameExp));
//Now try this again without short-circuiting
_en1.Validate(club, report, ValidationReportDepth.All);
Assert.IsTrue(report.HasError(president, memberNameExp));
}
private void AssertNotEqual(EquatableExpression exp1, EquatableExpression exp2, IEqualityComparer <EquatableExpression> comparer)
{
Assert.IsFalse(comparer.Equals(exp1, exp2), "Expressions are equal");
Assert.AreNotEqual(comparer.GetHashCode(exp1), comparer.GetHashCode(exp2), "Hashcodes match");
}
private void AssertEqual(EquatableExpression exp1, EquatableExpression exp2, IEqualityComparer <EquatableExpression> comparer)
{
Assert.IsTrue(comparer.Equals(exp1, exp2), "Expressions are not equal");
Assert.AreEqual(comparer.GetHashCode(exp1), comparer.GetHashCode(exp2), "Hashcodes do not match");
}
