Add metadata strings for operators and improve CLI output

src/Analyzer.Cli/CommandLineParser.cs

@@ -80,7 +80,9 @@ private Command SetupAnalyzeTemplateCommand()
 
                     foreach (var evaluation in evaluations)
                     {
-                        Console.WriteLine($"{evaluation.RuleName}: {evaluation.RuleDescription}, Result: {evaluation.Passed.ToString()}");
+                        string resultString = GenerateResultString(evaluation, templateFilePath.FullName, parametersFilePath == null ? null : File.ReadAllText(parametersFilePath.FullName));
+
+                        Console.WriteLine($"\n\n{evaluation.RuleName}: {evaluation.RuleDescription}\n\tResult: {evaluation.Passed} {resultString}");
                     }
                 }
                 catch (Exception exp)
@@ -93,6 +95,34 @@ private Command SetupAnalyzeTemplateCommand()
             return analyzeTemplateCommand;
         }
 
+        private string GenerateResultString(Types.IEvaluation evaluation, string templateFilePath, string parametersFilePath)
+        {
+            string resultString = "";
+
+            if (!evaluation.Passed)
+            {
+                foreach (var innerEvaluation in evaluation.Evaluations)
+                {
+                    resultString += GenerateResultString(innerEvaluation, templateFilePath, parametersFilePath);
+
+                    foreach (var result in innerEvaluation.Results)
+                    {
+                        if (!innerEvaluation.Passed)
+                        {
+                            resultString += $"\n\tFile: {templateFilePath}";
+                            if (parametersFilePath != null)
+                            {
+                                resultString += $"\n\tParameters File: {parametersFilePath}";
+                            }
+                            resultString += $"\n\tLine: {result.LineNumber}\n\t{result.FailureMessage()}";
+                        }
+                    }
+                }
+            }
+
+            return resultString;
+        }
+
         private Command SetupAnalyzeDirectoryCommand()
         {
             // Setup analyze-directory 

src/Analyzer.JsonRuleEngine.UnitTests/LeafExpressionTests.cs

@@ -103,7 +103,7 @@ public void Evaluate_ValidScope_ReturnsResultsOfOperatorEvaluation(string resour
             mockResourcesResolved.Verify(s => s.ResolveResourceType(It.IsAny<string>()), Times.Never);
 
             // The original mock is returned from both mocks when calling Resolve for a path, so the JToken should always come from it.
-            mockJsonPathResolver.Verify(s => s.JToken, Times.Once);
+            mockJsonPathResolver.Verify(s => s.JToken, Times.Exactly(2));
             mockResourcesResolved.Verify(s => s.JToken, Times.Never);
 
             mockLeafExpressionOperator.Verify(o => o.EvaluateExpression(It.Is<JToken>(token => token == jsonToEvaluate)), Times.Once);

src/Analyzer.JsonRuleEngine/Expressions/AllOfExpression.cs

@@ -3,6 +3,7 @@
 
 using System;
 using System.Collections.Generic;
+using Microsoft.Azure.Templates.Analyzer.RuleEngines.JsonEngine.Constants;
 using Microsoft.Azure.Templates.Analyzer.Types;
 
 namespace Microsoft.Azure.Templates.Analyzer.RuleEngines.JsonEngine.Expressions
@@ -26,6 +27,7 @@ public AllOfExpression(Expression[] expressions, ExpressionCommonProperties comm
             : base(commonProperties)
         {
             this.AllOf = expressions ?? throw new ArgumentNullException(nameof(expressions));
+            this.FailureMessage = JsonRuleEngineConstants.AllOfFailureMessage;
         }
 
         /// <summary>

src/Analyzer.JsonRuleEngine/Expressions/AnyOfExpression.cs

@@ -3,6 +3,7 @@
 
 using System;
 using System.Collections.Generic;
+using Microsoft.Azure.Templates.Analyzer.RuleEngines.JsonEngine.Constants;
 using Microsoft.Azure.Templates.Analyzer.Types;
 
 namespace Microsoft.Azure.Templates.Analyzer.RuleEngines.JsonEngine.Expressions
@@ -26,6 +27,7 @@ public AnyOfExpression(Expression[] expressions, ExpressionCommonProperties comm
             : base(commonProperties)
         {
             this.AnyOf = expressions ?? throw new ArgumentNullException(nameof(expressions));
+            this.FailureMessage = JsonRuleEngineConstants.AnyOfFailureMessage;
         }
 
         /// <summary>

src/Analyzer.JsonRuleEngine/Expressions/Expression.cs

@@ -28,6 +28,11 @@ internal abstract class Expression
         /// </summary>
         public Expression Where { get; private set; }
 
+        /// <summary>
+        /// Gets the messsage which explains why the evaluation failed.
+        /// </summary>
+        public string FailureMessage { get; internal set; }
+
         /// <summary>
         /// Initialization for the base Expression.
         /// </summary>
@@ -37,7 +42,6 @@ internal Expression(ExpressionCommonProperties commonProperties)
             (this.ResourceType, this.Path, this.Where) = (commonProperties.ResourceType, commonProperties.Path, commonProperties.Where);
         }
 
-
         /// <summary>
         /// Executes this <see cref="Expression"/> against a template.
         /// </summary>

src/Analyzer.JsonRuleEngine/Expressions/LeafExpression.cs

@@ -28,6 +28,7 @@ public LeafExpression(ILineNumberResolver jsonLineNumberResolver, LeafExpression
         {
             this.jsonLineNumberResolver = jsonLineNumberResolver ?? throw new ArgumentNullException(nameof(jsonLineNumberResolver));
             this.Operator = @operator ?? throw new ArgumentNullException(nameof(@operator));
+            this.FailureMessage = Operator.FailureMessage;
 
             if (commonProperties.Path == null) throw new ArgumentException("Path property must not be null.", nameof(commonProperties));
         }
@@ -51,7 +52,8 @@ public override JsonRuleEvaluation Evaluate(IJsonPathResolver jsonScope)
                     Passed = Operator.EvaluateExpression(scope.JToken),
                     JsonPath = scope.Path,
                     LineNumber = this.jsonLineNumberResolver.ResolveLineNumber(scope.Path),
-                    Expression = this
+                    Expression = this,
+                    ActualValue = scope.JToken
                 };
 
                 return result;

src/Analyzer.JsonRuleEngine/JsonRuleEngineConstants.cs

@@ -0,0 +1,26 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+namespace Microsoft.Azure.Templates.Analyzer.RuleEngines.JsonEngine.Constants
+{
+    /// <summary>
+    /// Defines all constants used in JsonEngine
+    /// </summary>
+    internal class JsonRuleEngineConstants
+    {
+        internal const string ActualValuePlaceholder = "{actualValue}";
+        internal const string PathPlaceholder = "{path}";
+        internal const string ExpectedValuePlaceholder = "{expectedValue}";
+        internal const string NegationPlaceholder = "{negation}";
+
+        internal static string EqualsFailureMessage = $"Value \"{ActualValuePlaceholder}\" found at \"{PathPlaceholder}\" is {NegationPlaceholder} equal to \"{ExpectedValuePlaceholder}\".";
+        internal static string ExistsFailureMessage = $"Value found at \"{PathPlaceholder}\" exists: {ActualValuePlaceholder}, expected: {ExpectedValuePlaceholder}.";
+        internal static string HasValueFailureMessage = $"Value found at \"{PathPlaceholder}\" has a value: {ActualValuePlaceholder}, expected: {ExpectedValuePlaceholder}.";
+        internal static string RegexFailureMessage = $"Value \"{ActualValuePlaceholder}\" found at \"{PathPlaceholder}\" does not match regex pattern: \"{ExpectedValuePlaceholder}\".";
+        internal static string InFailureMessage = $"Value \"{ExpectedValuePlaceholder}\" is not in the list at path \"{PathPlaceholder}\".";
+
+        internal static string AnyOfFailureMessage = $"No evaluations evaluted to true for the following json property: \"{PathPlaceholder}\".";
+        internal static string AllOfFailureMessage = $"One or more evaluations were false for the following json property: \"{PathPlaceholder}\".";
+
+    }
+}

src/Analyzer.JsonRuleEngine/JsonRuleResult.cs

@@ -1,8 +1,10 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
+using Microsoft.Azure.Templates.Analyzer.RuleEngines.JsonEngine.Constants;
 using Microsoft.Azure.Templates.Analyzer.RuleEngines.JsonEngine.Expressions;
 using Microsoft.Azure.Templates.Analyzer.Types;
+using Newtonsoft.Json.Linq;
 
 namespace Microsoft.Azure.Templates.Analyzer.RuleEngines.JsonEngine
 {
@@ -27,8 +29,32 @@ internal class JsonRuleResult : IResult
         internal string JsonPath { get; set; }
 
         /// <summary>
-        /// Gets the expression associated with this result
+        /// Gets the expression associated with this result.
         /// </summary>
         internal Expression Expression { get; set; }
+
+        /// <summary>
+        /// Gets the actual value present at the specified path.
+        /// </summary>
+        internal JToken ActualValue { get; set; }
+
+        /// <summary>
+        /// Gets the messsage which explains why the evaluation failed.
+        /// </summary>
+        public string FailureMessage()
+        {
+            string failureMessage = Expression.FailureMessage;
+
+            if (Expression is LeafExpression)
+            {
+                string expectedValue = ((Expression as LeafExpression).Operator.SpecifiedValue == null || (Expression as LeafExpression).Operator.SpecifiedValue.ToObject<object>() == null) ? "null" : (Expression as LeafExpression).Operator.SpecifiedValue.ToString();
+                failureMessage = failureMessage.Replace(JsonRuleEngineConstants.ExpectedValuePlaceholder, expectedValue);
+                failureMessage = failureMessage.Replace(JsonRuleEngineConstants.NegationPlaceholder, (Expression as LeafExpression).Operator.IsNegative ? "" : "not");
+            }
+
+            string actualValue = (ActualValue == null || ActualValue.ToObject<object>() == null) ? "null" : ActualValue.ToString();
+            failureMessage = failureMessage.Replace(JsonRuleEngineConstants.ActualValuePlaceholder, actualValue);
+            return failureMessage.Replace(JsonRuleEngineConstants.PathPlaceholder, JsonPath);
+        }
     }
 }

src/Analyzer.JsonRuleEngine/Operators/EqualsOperator.cs

@@ -2,6 +2,7 @@
 // Licensed under the MIT License.
 
 using System;
+using Microsoft.Azure.Templates.Analyzer.RuleEngines.JsonEngine.Constants;
 using Newtonsoft.Json.Linq;
 
 namespace Microsoft.Azure.Templates.Analyzer.RuleEngines.JsonEngine.Operators
@@ -23,6 +24,7 @@ public EqualsOperator(JToken specifiedValue, bool isNegative)
         {
             this.SpecifiedValue = specifiedValue ?? throw new ArgumentNullException(nameof(specifiedValue));
             this.IsNegative = isNegative;
+            this.FailureMessage = $"{this.Name}: {JsonRuleEngineConstants.EqualsFailureMessage}";
         }
 
         /// <summary>

src/Analyzer.JsonRuleEngine/Operators/ExistsOperator.cs

@@ -1,6 +1,7 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
+using Microsoft.Azure.Templates.Analyzer.RuleEngines.JsonEngine.Constants;
 using Newtonsoft.Json.Linq;
 
 namespace Microsoft.Azure.Templates.Analyzer.RuleEngines.JsonEngine.Operators
@@ -30,6 +31,7 @@ public ExistsOperator(bool specifiedValue, bool isNegative)
             (this.SpecifiedValue, this.IsNegative) = (specifiedValue, isNegative);
 
             this.EffectiveValue = specifiedValue;
+            this.FailureMessage = $"{this.Name}: {JsonRuleEngineConstants.ExistsFailureMessage}";
         }
 
         /// <summary>

src/Analyzer.JsonRuleEngine/Operators/HasValueOperator.cs

@@ -1,6 +1,7 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
+using Microsoft.Azure.Templates.Analyzer.RuleEngines.JsonEngine.Constants;
 using Newtonsoft.Json.Linq;
 
 namespace Microsoft.Azure.Templates.Analyzer.RuleEngines.JsonEngine.Operators
@@ -30,6 +31,7 @@ public HasValueOperator(bool specifiedValue, bool isNegative)
             (this.SpecifiedValue, this.IsNegative) = (specifiedValue, isNegative);
 
             this.EffectiveValue = specifiedValue;
+            this.FailureMessage = $"{this.Name}: {JsonRuleEngineConstants.HasValueFailureMessage}";
         }
 
         /// <summary>

src/Analyzer.JsonRuleEngine/Operators/InOperator.cs

@@ -1,6 +1,7 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
+using Microsoft.Azure.Templates.Analyzer.RuleEngines.JsonEngine.Constants;
 using Newtonsoft.Json.Linq;
 
 namespace Microsoft.Azure.Templates.Analyzer.RuleEngines.JsonEngine.Operators
@@ -23,6 +24,7 @@ public InOperator(JArray specifiedValue)
         {
             this.SpecifiedValue = specifiedValue;
             this.IsNegative = false;
+            this.FailureMessage = $"{this.Name}: {JsonRuleEngineConstants.InFailureMessage}";
         }
 
         /// <summary>

src/Analyzer.JsonRuleEngine/Operators/LeafExpressionOperator.cs

@@ -25,6 +25,11 @@ internal abstract class LeafExpressionOperator
         /// </summary>
         public JToken SpecifiedValue { get; set; }
 
+        /// <summary>
+        /// Gets the failure message when the operator does not pass
+        /// </summary>
+        public string FailureMessage { get; set; }
+
         /// <summary>
         /// Evaluates the specified JToken using the defined operation of this <c>Operator</c>.
         /// </summary>

src/Analyzer.JsonRuleEngine/Operators/RegexOperator.cs

@@ -2,6 +2,7 @@
 // Licensed under the MIT License.
 
 using System.Text.RegularExpressions;
+using Microsoft.Azure.Templates.Analyzer.RuleEngines.JsonEngine.Constants;
 using Newtonsoft.Json.Linq;
 
 namespace Microsoft.Azure.Templates.Analyzer.RuleEngines.JsonEngine.Operators
@@ -36,6 +37,8 @@ public RegexOperator(string regexPattern)
             {
                 throw new System.ArgumentException($"Regex pattern is not valid.", e);
             }
+
+            this.FailureMessage = $"{this.Name}: {JsonRuleEngineConstants.RegexFailureMessage}";
         }
 
         /// <summary>

src/Analyzer.Types/IResult.cs

@@ -17,5 +17,10 @@ public interface IResult
         /// Gets the line number of the file where the rule was evaluated.
         /// </summary>
         public int LineNumber { get; }
+
+        /// <summary>
+        /// Gets the messsage which explains why the evaluation failed.
+        /// </summary>
+        public string FailureMessage();
     }
 }