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"); }