Resolve conflicts and clean up code

Author: MaggieKimani1

src/Microsoft.OpenApi/Reader/OpenApiModelFactory.cs

@@ -112,7 +112,7 @@ public static async Task<ReadResult> LoadAsync(Stream input, string format, Open
                 bufferedStream.Position = 0;
             }
 
-            using var reader = new StreamReader(bufferedStream);
+            using var reader = new StreamReader(bufferedStream, default, true, -1, settings.LeaveStreamOpen);
             return await LoadAsync(reader, format, settings, cancellationToken);
         }
 

src/Microsoft.OpenApi/Reader/V2/OpenApiResponseDeserializer.cs

@@ -1,4 +1,4 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
+// Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT license.
 
 using System;
@@ -133,7 +133,7 @@ private static Dictionary<string, OpenApiExample> LoadExamplesExtension(ParseNod
                             example.Description = valueNode.Value.GetScalarValue();
                             break;
                         case "value":
-                            example.Value = OpenApiAnyConverter.GetSpecificOpenApiAny(valueNode.Value.CreateAny());
+                            example.Value = valueNode.Value.CreateAny();
                             break;
                         case "externalValue":
                             example.ExternalValue = valueNode.Value.GetScalarValue();

src/Microsoft.OpenApi/Validations/OpenApiValidator.cs

@@ -1,3 +1,4 @@
+
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT license.
 
@@ -293,15 +294,15 @@ private void Validate(object item, Type type)
             }
 
             // Validate unresolved references as references
-            if (item is IOpenApiReferenceable {UnresolvedReference: true})
+            if (item is IOpenApiReferenceable { UnresolvedReference: true })
             {
                 type = typeof(IOpenApiReferenceable);
             }
 
-            var rules = _ruleSet.FindRules(type.Name);
+            var rules = _ruleSet.FindRules(type);
             foreach (var rule in rules)
             {
-                rule.Evaluate(this as IValidationContext, item);
+                rule.Evaluate(this, item);
             }
         }
     }

src/Microsoft.OpenApi/Validations/Rules/JsonSchemaRules.cs

@@ -1,4 +1,4 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
+// Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT license. 
 
 using System.Collections.Generic;
@@ -21,7 +21,7 @@ public static class JsonSchemaRules
         /// Validate the data matches with the given data type.
         /// </summary>
         public static ValidationRule<JsonSchema> SchemaMismatchedDataType =>
-            new ValidationRule<JsonSchema>(
+            new ValidationRule<JsonSchema>(nameof(SchemaMismatchedDataType),
                 (context, jsonSchema) =>
                 {
                     // default
@@ -79,7 +79,7 @@ public static class JsonSchemaRules
         /// Validates Schema Discriminator
         /// </summary>
         public static ValidationRule<JsonSchema> ValidateSchemaDiscriminator =>
-            new ValidationRule<JsonSchema>(
+            new ValidationRule<JsonSchema>(nameof(ValidateSchemaDiscriminator),
                 (context, jsonSchema) =>
                 {
                     // discriminator

src/Microsoft.OpenApi/Validations/ValidationRuleSet.cs

@@ -1,4 +1,5 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
+
+// Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT license.
 
 using System;
@@ -8,6 +9,7 @@
 using Microsoft.OpenApi.Exceptions;
 using Microsoft.OpenApi.Properties;
 using Microsoft.OpenApi.Validations.Rules;
+using System.Data;
 
 namespace Microsoft.OpenApi.Validations
 {
@@ -16,16 +18,12 @@ namespace Microsoft.OpenApi.Validations
     /// </summary>
     public sealed class ValidationRuleSet
     {
-        private Dictionary<string, IList<ValidationRule>> _rulesDictionary = new();
+        private Dictionary<Type, IList<ValidationRule>> _rulesDictionary = new();
 
         private static ValidationRuleSet _defaultRuleSet;
 
         private List<ValidationRule> _emptyRules = new();
 
-        /// <summary>
-        /// Gets the keys in this rule set.
-        /// </summary>
-        public ICollection<string> Keys => _rulesDictionary.Keys;
 
         /// <summary>
         /// Gets the rules in this rule set.
@@ -45,13 +43,13 @@ public ValidationRuleSet()
         }
 
         /// <summary>
-        /// Retrieve the rules that are related to a specific key.
+        /// Retrieve the rules that are related to a specific type
         /// </summary>
-        /// <param name="key">The key of the rules to search for.</param>
-        /// <returns>Either the rules related to the given key, or an empty list.</returns>
-        public IList<ValidationRule> FindRules(string key)
+        /// <param name="type">The type that is to be validated</param>
+        /// <returns>Either the rules related to the type, or an empty list.</returns>
+        public IList<ValidationRule> FindRules(Type type)
         {
-            _rulesDictionary.TryGetValue(key, out var results);
+            _rulesDictionary.TryGetValue(type, out var results);
             return results ?? _emptyRules;
         }
 
@@ -92,7 +90,7 @@ public static ValidationRuleSet GetEmptyRuleSet()
         /// <param name="ruleSet">The rule set to add validation rules to.</param>
         /// <param name="rules">The validation rules to be added to the rules set.</param>
         /// <exception cref="OpenApiException">Throws a null argument exception if the arguments are null.</exception>
-        public static void AddValidationRules(ValidationRuleSet ruleSet, IDictionary<string, IList<ValidationRule>> rules)
+        public static void AddValidationRules(ValidationRuleSet ruleSet, IDictionary<Type, IList<ValidationRule>> rules)
         {
             if (ruleSet == null || rules == null)
             {
@@ -118,15 +116,15 @@ public ValidationRuleSet(ValidationRuleSet ruleSet)
 
             foreach (var rule in ruleSet)
             {
-                Add(rule.ElementType.Name, rule);
+                Add(rule.ElementType, rule);
             }
         }
 
         /// <summary>
         /// Initializes a new instance of the <see cref="ValidationRuleSet"/> class.
         /// </summary>
         /// <param name="rules">Rules to be contained in this ruleset.</param>
-        public ValidationRuleSet(IDictionary<string, IList<ValidationRule>> rules)
+        public ValidationRuleSet(IDictionary<Type, IList<ValidationRule>> rules)
         {
             if (rules == null)
             {
@@ -144,7 +142,7 @@ public ValidationRuleSet(IDictionary<string, IList<ValidationRule>> rules)
         /// </summary>
         /// <param name="key">The key for the rule.</param>
         /// <param name="rules">The list of rules.</param>
-        public void Add(string key, IList<ValidationRule> rules)
+        public void Add(Type key, IList<ValidationRule> rules)
         {
             foreach (var rule in rules)
             {
@@ -158,7 +156,7 @@ public void Add(string key, IList<ValidationRule> rules)
         /// <param name="key">The key for the rule.</param>
         /// <param name="rule">The rule.</param>
         /// <exception cref="OpenApiException">Exception thrown when rule already exists.</exception>
-        public void Add(string key, ValidationRule rule)
+        public void Add(Type key, ValidationRule rule)
         {
             if (!_rulesDictionary.ContainsKey(key))
             {
@@ -180,7 +178,7 @@ public void Add(string key, ValidationRule rule)
         /// <param name="newRule">The new rule.</param>
         /// <param name="oldRule">The old rule.</param>
         /// <returns>true, if the update was successful; otherwise false.</returns>
-        public bool Update(string key, ValidationRule newRule, ValidationRule oldRule)
+        public bool Update(Type key, ValidationRule newRule, ValidationRule oldRule)
         {
             if (_rulesDictionary.TryGetValue(key, out var currentRules))
             {
@@ -195,18 +193,33 @@ public bool Update(string key, ValidationRule newRule, ValidationRule oldRule)
         /// </summary>
         /// <param name="key">The key of the collection of rules to be removed.</param>
         /// <returns>true if the collection of rules with the provided key is removed; otherwise, false.</returns>
-        public bool Remove(string key)
+        public bool Remove(Type key)
         {
             return _rulesDictionary.Remove(key);
         }
 
+        /// <summary>
+        /// Remove a rule by its name from all types it is used by.
+        /// </summary>        
+        /// <param name="ruleName">Name of the rule.</param>
+        public void Remove(string ruleName)
+        {
+            foreach (KeyValuePair<Type, IList<ValidationRule>> rule in _rulesDictionary)
+            {
+                _rulesDictionary[rule.Key] = rule.Value.Where(vr => !vr.Name.Equals(ruleName, StringComparison.Ordinal)).ToList();
+            }
+
+            // Remove types with no rule
+            _rulesDictionary = _rulesDictionary.Where(r => r.Value.Any()).ToDictionary(r => r.Key, r => r.Value);
+        }
+
         /// <summary>
         /// Removes a rule by key.
         /// </summary>
         /// <param name="key">The key of the rule to be removed.</param>
         /// <param name="rule">The rule to be removed.</param>
         /// <returns>true if the rule is successfully removed; otherwise, false.</returns>
-        public bool Remove(string key, ValidationRule rule)
+        public bool Remove(Type key, ValidationRule rule)
         {
             if (_rulesDictionary.TryGetValue(key, out IList<ValidationRule> validationRules))
             {
@@ -239,7 +252,7 @@ public void Clear()
         /// </summary>
         /// <param name="key">The key to locate in the rule set.</param>
         /// <returns>true if the rule set contains an element with the key; otherwise, false.</returns>
-        public bool ContainsKey(string key)
+        public bool ContainsKey(Type key)
         {
             return _rulesDictionary.ContainsKey(key);
         }
@@ -250,7 +263,7 @@ public bool ContainsKey(string key)
         /// <param name="key">The key to locate.</param>
         /// <param name="rule">The rule to locate.</param>
         /// <returns></returns>
-        public bool Contains(string key, ValidationRule rule)
+        public bool Contains(Type key, ValidationRule rule)
         {
             return _rulesDictionary.TryGetValue(key, out IList<ValidationRule> validationRules) && validationRules.Contains(rule);
         }
@@ -263,35 +276,11 @@ public bool Contains(string key, ValidationRule rule)
         ///  key is found; otherwise, an empty <see cref="IList{ValidationRule}"/> object.
         ///  This parameter is passed uninitialized.</param>
         /// <returns>true if the specified key has rules.</returns>
-        public bool TryGetValue(string key, out IList<ValidationRule> rules)
+        public bool TryGetValue(Type key, out IList<ValidationRule> rules)
         {
             return _rulesDictionary.TryGetValue(key, out rules);
         }
 
-        /// <summary>
-        /// Remove a rule by its name from all types it is used by.
-        /// </summary>        
-        /// <param name="ruleName">Name of the rule.</param>
-        public void Remove(string ruleName)
-        {
-            foreach (KeyValuePair<Type, IList<ValidationRule>> rule in _rules)
-            {
-                _rules[rule.Key] = rule.Value.Where(vr => !vr.Name.Equals(ruleName, StringComparison.Ordinal)).ToList();                
-            }
-
-            // Remove types with no rule
-            _rules = _rules.Where(r => r.Value.Any()).ToDictionary(r => r.Key, r => r.Value);
-        }
-
-        /// <summary>
-        /// Remove a rule by element type.
-        /// </summary>        
-        /// <param name="type">Type of the rule.</param>
-        public void Remove(Type type)
-        {
-            _rules.Remove(type);
-        }
-
         /// <summary>
         /// Get the enumerator.
         /// </summary>
@@ -324,7 +313,7 @@ private static ValidationRuleSet BuildDefaultRuleSet()
                 var propertyValue = property.GetValue(null); // static property
                 if (propertyValue is ValidationRule rule)
                 {
-                    ruleSet.Add(rule.ElementType.Name, rule);
+                    ruleSet.Add(rule.ElementType, rule);
                 }
             }
 

test/Microsoft.OpenApi.Readers.Tests/OpenApiReaderTests/OpenApiStreamReaderTests.cs

@@ -45,8 +45,7 @@ public async void StreamShouldNotBeDisposedIfLeaveStreamOpenSettingIsTrue()
             memoryStream.Position = 0;
             var stream = memoryStream;
 
-            var reader = new OpenApiStreamReader(new() { LeaveStreamOpen = true });
-            _ = await reader.ReadAsync(stream);
+            var result = OpenApiDocument.Load(stream, "yaml", new OpenApiReaderSettings { LeaveStreamOpen = true });
             stream.Seek(0, SeekOrigin.Begin); // does not throw an object disposed exception
             Assert.True(stream.CanRead);
         }

test/Microsoft.OpenApi.Readers.Tests/V2Tests/OpenApiOperationTests.cs

@@ -1,4 +1,4 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
+// Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT license. 
 
 using System.Collections.Generic;
@@ -9,10 +9,13 @@
 using Json.Schema;
 using Microsoft.OpenApi.Any;
 using Microsoft.OpenApi.Extensions;
+using Microsoft.OpenApi.Interfaces;
 using Microsoft.OpenApi.Models;
 using Microsoft.OpenApi.Reader.ParseNodes;
 using Microsoft.OpenApi.Reader.V2;
+using Microsoft.OpenApi.Reader.V3;
 using Microsoft.OpenApi.Tests;
+using Microsoft.OpenApi.Writers;
 using Xunit;
 
 namespace Microsoft.OpenApi.Readers.Tests.V2Tests
@@ -305,36 +308,30 @@ public void ParseOperationWithEmptyProducesArraySetsResponseSchemaIfExists()
 
             // Act
             var operation = OpenApiV2Deserializer.LoadOperation(node);
+            var expected = @"{
+  ""produces"": [
+    ""application/octet-stream""
+  ],
+  ""responses"": {
+    ""200"": {
+      ""description"": ""OK"",
+      ""schema"": {
+        ""type"": ""string"",
+        ""description"": ""The content of the file."",
+        ""format"": ""binary"",
+        ""x-ms-summary"": ""File Content""
+      }
+    }
+  }
+}";
+
+            var stringBuilder = new StringBuilder();
+            var jsonWriter = new OpenApiJsonWriter(new StringWriter(stringBuilder));
+            operation.SerializeAsV2(jsonWriter);
 
             // Assert
-            operation.Should().BeEquivalentTo(
-                new OpenApiOperation
-                {
-                    Responses = new()
-                    {
-                        { "200", new()
-                        {
-                            Description = "OK",
-                            Content =
-                            {
-                                ["application/octet-stream"] = new()
-                                {
-                                    Schema = new()
-                                    {
-                                        Format = "binary",
-                                        Description = "The content of the file.",
-                                        Type = "string",
-                                        Extensions =
-                                        {
-                                            ["x-ms-summary"] = new OpenApiString("File Content")
-                                        }
-                                    }
-                                }
-                            }
-                        }}
-                    }
-                }
-            );
+            var actual = stringBuilder.ToString();
+            actual.MakeLineBreaksEnvironmentNeutral().Should().BeEquivalentTo(expected.MakeLineBreaksEnvironmentNeutral());            
         }
 
         [Fact]
@@ -349,7 +346,7 @@ public void ParseOperationWithBodyAndEmptyConsumesSetsRequestBodySchemaIfExists(
             var operation = OpenApiV2Deserializer.LoadOperation(node);
 
             // Assert
-            operation.Should().BeEquivalentTo(_operationWithBody);
+            operation.Should().BeEquivalentTo(_operationWithBody, options => options.IgnoringCyclicReferences());
         }
 
         [Fact]