Example #1
0
        public void NullPattern_is_triggered()
        {
            string notNullString = "a string";

            var failures = new AssertionFailureAnalyzer(CreateContext(() => notNullString == null)).AnalyzeAssertionFailures();

            Assert(() => failures.Count == 1 && failures[0].FriendlyMessagePattern is NullPattern);
        }
Example #2
0
        public void AnyPattern_is_triggered()
        {
            var list = new List <string>
            {
                "a", "b", "c"
            };

            var failures = new AssertionFailureAnalyzer(new AssertionFailureContext(new Assertion(() => list.Any(l => l.Length > 1), null, null), null)).AnalyzeAssertionFailures();

            Assert(() => failures.Count == 1 && failures[0].FriendlyMessagePattern is AnyPattern);
        }
Example #3
0
        public FormattableString TryGetFriendlyMessage(FailedAssertion assertion)
        {
            var methodCallExpression = (MethodCallExpression)assertion.Expression;

            var collectionExpression = ExpressionHelper.GetInstanceOfMethodCall(methodCallExpression);

            var filter = (LambdaExpression)methodCallExpression.Arguments[1];

            var collection = ((IEnumerable)ExpressionHelper.EvaluateExpression(collectionExpression) !).Cast <object>();

            var compiledFilter = filter.Compile(true);

            var invalidMatches = new List <object>();

            var moreItems    = false;
            var invalidCount = 0;

            var subMessages = new List <FormattableString>();

            var index = 0;

            foreach (var obj in collection)
            {
                var isMatch = (bool)compiledFilter.DynamicInvoke(obj);

                if (!isMatch)
                {
                    invalidCount++;

                    if (invalidMatches.Count == 10)
                    {
                        moreItems = true;
                    }
                    else
                    {
                        invalidMatches.Add(obj);

                        var namedConstant = new NamedConstantExpression("item", obj);

                        var newExpression =
                            Expression.Lambda <Func <bool> >(
                                ExpressionHelper.ReplaceParameter(filter.Body, filter.Parameters[0], namedConstant));

                        var analyzer = new AssertionFailureAnalyzer(new AssertionFailureContext(new Assertion(newExpression, null, null), null));

                        var failures = analyzer.AnalyzeAssertionFailures();

                        foreach (var failure in failures)
                        {
                            if (failure.Message != null)
                            {
                                subMessages.Add(collectionExpression is MethodCallExpression
                  ? $"[{index}] - {failure.Message}"
                  : (FormattableString)$"{collectionExpression}[{index}] - {failure.Message}");
                            }
                        }
                    }
                }

                index++;
            }

            FormattableString MessagesPerItem()
            {
                return(subMessages.Count switch
                {
                    0 => $"",
                    1 when invalidCount == 1 => $@"

{subMessages[0]}",
                    _ => $@"

Messages per item:

{subMessages}"
                });
            }