- Modify / Rewrite majority of V3 reader tests

- Restructure the tests to resemble the deserializers. Future tests can now be written per object type.

Author: PerthCharern

src/Microsoft.OpenApi.Readers/OpenApiError.cs

@@ -12,34 +12,40 @@ namespace Microsoft.OpenApi.Readers
     /// </summary>
     public class OpenApiError
     {
-        private readonly string _message;
-        private readonly string _pointer;
+        /// <summary>
+        /// Message explaining the error.
+        /// </summary>
+        public string Message { get; set; }
+
+        /// <summary>
+        /// Pointer to the location of the error.
+        /// </summary>
+        public string Pointer { get; set; }
 
         /// <summary>
         /// Initializes the <see cref="OpenApiError"/> class using the message and pointer from the given exception.
         /// </summary>
         public OpenApiError(OpenApiException exception)
         {
-            _message = exception.Message;
-            _pointer = exception.Pointer;
+            Message = exception.Message;
+            Pointer = exception.Pointer;
         }
 
         /// <summary>
         /// Initializes the <see cref="OpenApiError"/> class.
         /// </summary>
         public OpenApiError(string pointer, string message)
         {
-            this._pointer = pointer;
-            this._message = message;
+            this.Pointer = pointer;
+            this.Message = message;
         }
 
         /// <summary>
         /// Gets the string representation of <see cref="OpenApiError"/>.
         /// </summary>
-        /// <returns></returns>
         public override string ToString()
         {
-            return _message + (!string.IsNullOrEmpty(_pointer) ? " at " + _pointer : "");
+            return Message + (!string.IsNullOrEmpty(Pointer) ? " at " + Pointer : "");
         }
     }
 }

src/Microsoft.OpenApi.Readers/ParseNodes/MapNode.cs

@@ -35,7 +35,7 @@ public MapNode(ParsingContext context, OpenApiDiagnostic diagnostic, YamlMapping
         {
             if (node == null)
             {
-                throw new OpenApiException($"Expected map");
+                throw new OpenApiException("Expected map");
             }
 
             this.node = node;
@@ -72,8 +72,12 @@ public override Dictionary<string, T> CreateMap<T>(Func<MapNode, T> map)
                 n => new
                 {
                     key = n.Key.GetScalarValue(),
-                    value = map(new MapNode(Context, Diagnostic, n.Value as YamlMappingNode))
+                    value = n.Value as YamlMappingNode == null ?
+                        default(T) :
+                        map(new MapNode(Context, Diagnostic, n.Value as YamlMappingNode))
+
                 });
+
             return nodes.ToDictionary(k => k.key, v => v.value);
         }
 

src/Microsoft.OpenApi.Readers/V2/OpenApiV2Deserializer.cs

@@ -36,7 +36,11 @@ private static void ParseMap<T>(
 
         private static void ReportMissing(ParseNode node, IList<string> required)
         {
-            foreach (var error in required.Select(r => new OpenApiError("", $"{r} is a required property")).ToList())
+            foreach (var error in required.Select(
+                    r => new OpenApiError(
+                        node.Context.GetLocation(),
+                        $"{r} is a required property"))
+                .ToList())
             {
                 node.Diagnostic.Errors.Add(error);
             }

src/Microsoft.OpenApi.Readers/V3/OpenApiMediaTypeDeserializer.cs

@@ -49,18 +49,18 @@ internal static partial class OpenApiV3Deserializer
 
         public static OpenApiMediaType LoadMediaType(ParseNode node)
         {
-            var mapNode = node.CheckMapNode("contentType");
+            var mapNode = node.CheckMapNode("content");
 
             if (!mapNode.Any())
             {
                 return null;
             }
 
-            var contentType = new OpenApiMediaType();
+            var mediaType = new OpenApiMediaType();
 
-            ParseMap(mapNode, contentType, MediaTypeFixedFields, MediaTypePatternFields);
+            ParseMap(mapNode, mediaType, MediaTypeFixedFields, MediaTypePatternFields);
 
-            return contentType;
+            return mediaType;
         }
     }
 }

src/Microsoft.OpenApi.Readers/V3/OpenApiV3Deserializer.cs

@@ -70,7 +70,9 @@ private static void ReportMissing(ParseNode node, IList<string> required)
             }
 
             foreach (var error in required.Select(
-                    r => new OpenApiError("", $"{r} is a required property of {node.Context.GetLocation()}"))
+                    r => new OpenApiError(
+                        node.Context.GetLocation(),
+                        $"{r} is a required property"))
                 .ToList())
             {
                 node.Diagnostic.Errors.Add(error);

src/Microsoft.OpenApi.Readers/YamlHelper.cs

@@ -28,6 +28,7 @@ public static YamlNode ParseYamlString(string yamlString)
             var reader = new StringReader(yamlString);
             var yamlStream = new YamlStream();
             yamlStream.Load(reader);
+
             var yamlDocument = yamlStream.Documents.First();
             return yamlDocument.RootNode;
         }

src/Microsoft.OpenApi/Expressions/RuntimeExpression.cs

@@ -12,7 +12,7 @@ namespace Microsoft.OpenApi.Expressions
     /// <summary>
     /// Base class for the Open API runtime expression.
     /// </summary>
-    public abstract class RuntimeExpression
+    public abstract class RuntimeExpression : IEquatable<RuntimeExpression>
     {
         /// <summary>
         /// The dollar sign prefix for a runtime expression.
@@ -77,5 +77,29 @@ public static RuntimeExpression Build(string expression)
 
             throw new OpenApiException(String.Format(SRResource.RuntimeExpressionHasInvalidFormat, expression));
         }
+
+        /// <summary>
+        /// GetHashCode implementation for IEquatable.
+        /// </summary>
+        public override int GetHashCode()
+        {
+            return Expression.GetHashCode();
+        }
+
+        /// <summary>
+        /// Equals implementation for IEquatable.
+        /// </summary>
+        public override bool Equals(object obj)
+        {
+            return Equals(obj as RuntimeExpression);
+        }
+
+        /// <summary>
+        /// Equals implementation for object of the same type.
+        /// </summary>
+        public bool Equals(RuntimeExpression obj)
+        {
+            return obj != null && obj.Expression == Expression;
+        }
     }
 }

src/Microsoft.OpenApi/Models/OpenApiConstants.cs

@@ -7,6 +7,9 @@
 
 namespace Microsoft.OpenApi.Models
 {
+    /// <summary>
+    /// Constants used in the Open API document.
+    /// </summary>
     public static class OpenApiConstants
     {
         public const string OpenApi = "openapi";

src/Microsoft.OpenApi/Models/OpenApiReference.cs

@@ -209,7 +209,9 @@ private string GetReferenceTypeNameAsV2(ReferenceType type)
                     return OpenApiConstants.SecurityDefinitions;
 
                 default:
-                    throw new OpenApiException(string.Format(SRResource.ReferenceTypeNotSupportedV2, type));
+                    // If the reference type is not supported in V2, simply return null
+                    // to indicate that the reference is not pointing to any object.
+                    return null;
             }
         }
     }