public override ConstraintResult ApplyTo <TActual>(TActual actual)
        {
            var cresult = new CustomConstraintResult(this, actual)
            {
                Status = ConstraintStatus.Error
            };

            var matcher = new EntityValidationStrategy();
            var result  = matcher.Validate(actual, validationType);

            cresult.Status = result.All(x => x.Success) ? ConstraintStatus.Success : ConstraintStatus.Failure;

            foreach (var mismatch in result.Where(mismatch => !mismatch.Success))
            {
                messageList.Add(mismatch.GetMessage());
            }
            cresult.MessageList = messageList;
            return(cresult);
        }
Esempio n. 2
0
        public override ConstraintResult ApplyTo <TActual>(TActual actual)
        {
            var cresult = new CustomConstraintResult(this, actual)
            {
                Status = ConstraintStatus.Error
            };

            if (!(actual is IList))
            {
                throw new InvalidOperationException("Actual object should be a list");
            }
            var actualAndDiff = new Dictionary <object, List <string> >();

            foreach (var actualItem in ((IList)actual))
            {
                var propertyValidator = new EntityEqualityConstraint(expected);
                if (propertyValidator.Matches(actualItem))
                {
                    cresult.Status = ConstraintStatus.Success;
                    return(cresult);
                }
                actualAndDiff.Add(actualItem, propertyValidator.Differences);
            }
            switch (actionOnFailure)
            {
            case OnListContainsFailure.DoNothing:
                break;

            case OnListContainsFailure.DisplayExpectedAndActualList:
                messageList.Add("Expected item:{0}");
                messageList.Add(Describe.Object(expected));
                var position = 0;
                messageList.Add("Actual List:");
                foreach (var item in ((IList)actual))
                {
                    messageList.Add($"Item[{position}]");
                    messageList.Add(Describe.Object(item));
                    position++;
                }

                break;

            case OnListContainsFailure.DisplayClosestMatch:
                var biggestDifference  = actualAndDiff.Max(x => x.Value.Count);
                var smallestDifference = actualAndDiff.Min(x => x.Value.Count);
                if (biggestDifference != smallestDifference || actualAndDiff.Count == 1)
                {
                    var closestMatches = actualAndDiff.Where(x => x.Value.Count == smallestDifference);
                    messageList.Add("Expected item:");
                    messageList.Add(Describe.Object(expected));

                    messageList.Add("Closest matches:");
                    foreach (var closestMatch in closestMatches)
                    {
                        messageList.Add("Item Description:");
                        messageList.Add(Describe.Object(closestMatch.Key));
                        messageList.Add("Diff:");
                        foreach (var diff in closestMatch.Value)
                        {
                            messageList.Add(diff);
                        }
                    }
                }
                break;
            }

            cresult.MessageList = messageList;
            cresult.Status      = ConstraintStatus.Failure;
            return(cresult);
        }