Updates based on code review

Author: darrelmiller

src/Microsoft.OpenApi.Readers/Services/OpenApiReferenceResolver.cs

@@ -177,8 +177,7 @@ private void ResolveTags(IList<OpenApiTag> tags)
 
             if (IsUnresolvedReference(entity))
             {
-                var x = ResolveReference<T>(entity.Reference);
-                assign(x);
+                assign(ResolveReference<T>(entity.Reference));
             }
         }
 

src/Microsoft.OpenApi.Workbench/StatsVisitor.cs

@@ -8,7 +8,7 @@
 
 namespace Microsoft.OpenApi.Workbench
 {
-    public class StatsVisitor : OpenApiVisitorBase
+    internal class StatsVisitor : OpenApiVisitorBase
     {
         public int ParameterCount { get; set; } = 0;
 

src/Microsoft.OpenApi/Validations/OpenApiValidator.cs

@@ -168,7 +168,10 @@ private void Validate<T>(T item)
         /// </summary>
         private void Validate(object item, Type type)
         {
-            if (item == null) return;  // Required fields should be checked by higher level objects
+            if (item == null)
+            {
+                return;  // Required fields should be checked by higher level objects
+            }
 
             // Validate unresolved references as references
             var potentialReference = item as IOpenApiReferenceable;

src/Microsoft.OpenApi/Validations/ValidationRuleSet.cs

@@ -56,12 +56,16 @@ public static ValidationRuleSet GetDefaultRuleSet()
             return new ValidationRuleSet(_defaultRuleSet);
         }
 
+        /// <summary>
+        /// Return Ruleset with no rules
+        /// </summary>
         public static ValidationRuleSet GetEmptyRuleSet()
         {
             // We create a new instance of ValidationRuleSet per call as a safeguard
             // against unintentional modification of the private _defaultRuleSet.
             return new ValidationRuleSet();
         }
+
         /// <summary>
         /// Initializes a new instance of the <see cref="ValidationRuleSet"/> class.
         /// </summary>

test/Microsoft.OpenApi.Tests/Validations/OpenApiReferenceValidationTests.cs

@@ -1,4 +1,7 @@
-using System;
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license. 
+
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
@@ -64,12 +67,13 @@ public void ReferencedSchemaShouldOnlyBeValidatedOnce()
             };
 
             // Act
-            var errors = document.Validate(new ValidationRuleSet() { new AllwaysFailRule<OpenApiSchema>()});
+            var errors = document.Validate(new ValidationRuleSet() { new AlwaysFailRule<OpenApiSchema>()});
 
 
             // Assert
             Assert.True(errors.Count() == 1);            
         }
+
         [Fact]
         public void UnResolvedReferencedSchemaShouldNotBeValidated()
         {
@@ -94,17 +98,65 @@ public void UnResolvedReferencedSchemaShouldNotBeValidated()
             };
 
             // Act
-            var errors = document.Validate(new ValidationRuleSet() { new AllwaysFailRule<OpenApiSchema>() });
+            var errors = document.Validate(new ValidationRuleSet() { new AlwaysFailRule<OpenApiSchema>() });
 
             // Assert
             Assert.True(errors.Count() == 0);
         }
 
+        [Fact]
+        public void UnResolvedSchemaReferencedShouldNotBeValidated()
+        {
+            // Arrange
+
+            var sharedSchema = new OpenApiSchema
+            {
+                Reference = new OpenApiReference()
+                {
+                    Id = "test"
+                },
+                UnresolvedReference = true
+            };
+
+            OpenApiDocument document = new OpenApiDocument();
+
+            document.Paths = new OpenApiPaths()
+            {
+                ["/"] = new OpenApiPathItem()
+                {
+                    Operations = new Dictionary<OperationType, OpenApiOperation>
+                    {
+                        [OperationType.Get] = new OpenApiOperation()
+                        {
+                            Responses = new OpenApiResponses()
+                            {
+                                ["200"] = new OpenApiResponse()
+                                {
+                                    Content = new Dictionary<string, OpenApiMediaType>()
+                                    {
+                                        ["application/json"] = new OpenApiMediaType()
+                                        {
+                                            Schema = sharedSchema
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            };
+
+            // Act
+            var errors = document.Validate(new ValidationRuleSet() { new AlwaysFailRule<OpenApiSchema>() });
+
+            // Assert
+            Assert.True(errors.Count() == 0);
+        }
     }
 
-    public class AllwaysFailRule<P> : ValidationRule<P> where P: IOpenApiElement
+    public class AlwaysFailRule<T> : ValidationRule<T> where T: IOpenApiElement
     {
-        public AllwaysFailRule() : base( (c,t) =>  c.CreateError("x","y"))
+        public AlwaysFailRule() : base( (c,t) =>  c.CreateError("x","y"))
         {
 
         }