diff --git a/src/Microsoft.OpenApi/Properties/SRResource.Designer.cs b/src/Microsoft.OpenApi/Properties/SRResource.Designer.cs
index 96c0ce501..18f1a59d6 100644
--- a/src/Microsoft.OpenApi/Properties/SRResource.Designer.cs
+++ b/src/Microsoft.OpenApi/Properties/SRResource.Designer.cs
@@ -77,7 +77,18 @@ internal static string ArgumentNullOrWhiteSpace {
                 return ResourceManager.GetString("ArgumentNullOrWhiteSpace", resourceCulture);
             }
         }
-        
+
+        /// <summary>
+        ///   Looks up a localized string similar to The argument &apos;{0}&apos; is null..
+        /// </summary>
+        internal static string ArgumentNull
+        {
+            get
+            {
+                return ResourceManager.GetString("ArgumentNull", resourceCulture);
+            }
+        }
+
         /// <summary>
         ///   Looks up a localized string similar to The filed name &apos;{0}&apos; of extension doesn&apos;t begin with x-..
         /// </summary>
diff --git a/src/Microsoft.OpenApi/Validations/OpenApiValidator.cs b/src/Microsoft.OpenApi/Validations/OpenApiValidator.cs
index a0aee12e7..64f901c53 100644
--- a/src/Microsoft.OpenApi/Validations/OpenApiValidator.cs
+++ b/src/Microsoft.OpenApi/Validations/OpenApiValidator.cs
@@ -317,7 +317,7 @@ private void Validate(object item, Type type)
                 type = typeof(IOpenApiReferenceable);
             }
 
-            var rules = _ruleSet.FindRules(type);
+            var rules = _ruleSet.FindRules(type.Name);
             foreach (var rule in rules)
             {
                 rule.Evaluate(this as IValidationContext, item);
diff --git a/src/Microsoft.OpenApi/Validations/ValidationRuleSet.cs b/src/Microsoft.OpenApi/Validations/ValidationRuleSet.cs
index 11bc39f04..c34d4a451 100644
--- a/src/Microsoft.OpenApi/Validations/ValidationRuleSet.cs
+++ b/src/Microsoft.OpenApi/Validations/ValidationRuleSet.cs
@@ -4,7 +4,6 @@
 using System;
 using System.Linq;
 using System.Reflection;
-using System.Collections;
 using System.Collections.Generic;
 using Microsoft.OpenApi.Exceptions;
 using Microsoft.OpenApi.Properties;
@@ -15,23 +14,44 @@ namespace Microsoft.OpenApi.Validations
     /// <summary>
     /// The rule set of the validation.
     /// </summary>
-    public sealed class ValidationRuleSet : IEnumerable<ValidationRule>
+    public sealed class ValidationRuleSet
     {
-        private readonly IDictionary<Type, IList<ValidationRule>> _rules = new Dictionary<Type, IList<ValidationRule>>();
+        private readonly IDictionary<string, IList<ValidationRule>> _rulesDictionary = new Dictionary<string, IList<ValidationRule>>();
 
         private static ValidationRuleSet _defaultRuleSet;
 
         private readonly IList<ValidationRule> _emptyRules = new List<ValidationRule>();
 
         /// <summary>
-        /// Retrieve the rules that are related to a specific type
+        /// Gets the keys in this rule set.
         /// </summary>
-        /// <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)
+        public ICollection<string> Keys => _rulesDictionary.Keys;
+
+        /// <summary>
+        /// Gets the rules in this rule set.
+        /// </summary>
+        public IList<ValidationRule> Rules => _rulesDictionary.Values.SelectMany(v => v).ToList();
+
+        /// <summary>
+        /// Gets the number of elements contained in this rule set.
+        /// </summary>
+        public int Count => _rulesDictionary.Count;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ValidationRuleSet"/> class.
+        /// </summary>
+        public ValidationRuleSet()
+        {
+        }
+
+        /// <summary>
+        /// Retrieve the rules that are related to a specific key.
+        /// </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)
         {
-            IList<ValidationRule> results = null;
-            _rules.TryGetValue(type, out results);
+            _rulesDictionary.TryGetValue(key, out var results);
             return results ?? _emptyRules;
         }
 
@@ -67,10 +87,22 @@ public static ValidationRuleSet GetEmptyRuleSet()
         }
 
         /// <summary>
-        /// Initializes a new instance of the <see cref="ValidationRuleSet"/> class.
+        /// Add validation rules to the rule set.
         /// </summary>
-        public ValidationRuleSet()
+        /// <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)
         {
+            if (ruleSet == null || rules == null)
+            {
+                throw new OpenApiException(SRResource.ArgumentNull);
+            }
+
+            foreach (var rule in rules)
+            {
+                ruleSet.Add(rule.Key, rule.Value);
+            }
         }
 
         /// <summary>
@@ -86,7 +118,7 @@ public ValidationRuleSet(ValidationRuleSet ruleSet)
 
             foreach (ValidationRule rule in ruleSet)
             {
-                Add(rule);
+                Add(rule.ElementType.Name, rule);
             }
         }
 
@@ -94,71 +126,161 @@ public ValidationRuleSet(ValidationRuleSet ruleSet)
         /// Initializes a new instance of the <see cref="ValidationRuleSet"/> class.
         /// </summary>
         /// <param name="rules">Rules to be contained in this ruleset.</param>
-        public ValidationRuleSet(IEnumerable<ValidationRule> rules)
+        public ValidationRuleSet(IDictionary<string, IList<ValidationRule>> rules)
         {
             if (rules == null)
             {
                 return;
             }
 
-            foreach (ValidationRule rule in rules)
+            foreach (var rule in rules)
             {
-                Add(rule);
+                Add(rule.Key, rule.Value);
             }
         }
 
         /// <summary>
-        /// Gets the rules in this rule set.
+        /// Add the new rule into the rule set.
         /// </summary>
-        public IEnumerable<ValidationRule> Rules
+        /// <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)
         {
-            get
+            foreach (var rule in rules)
             {
-                return _rules.Values.SelectMany(v => v);
+                Add(key, rule);
             }
         }
 
         /// <summary>
-        /// Add the new rule into the rule set.
+        /// Add a new rule into the rule set.
         /// </summary>
+        /// <param name="key">The key for the rule.</param>
         /// <param name="rule">The rule.</param>
-        public void Add(ValidationRule rule)
+        /// <exception cref="OpenApiException">Exception thrown when rule already exists.</exception>
+        public void Add(string key, ValidationRule rule)
         {
-            if (!_rules.ContainsKey(rule.ElementType))
+            if (!_rulesDictionary.ContainsKey(key))
             {
-                _rules[rule.ElementType] = new List<ValidationRule>();
+                _rulesDictionary[key] = new List<ValidationRule>();
             }
 
-            if (_rules[rule.ElementType].Contains(rule))
+            if (_rulesDictionary[key].Contains(rule))
             {
                 throw new OpenApiException(SRResource.Validation_RuleAddTwice);
             }
 
-            _rules[rule.ElementType].Add(rule);
+            _rulesDictionary[key].Add(rule);
         }
 
         /// <summary>
-        /// Get the enumerator.
+        /// Updates an existing rule with a new one.
         /// </summary>
-        /// <returns>The enumerator.</returns>
-        public IEnumerator<ValidationRule> GetEnumerator()
+        /// <param name="key">The key of the existing rule.</param>
+        /// <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)
         {
-            foreach (var ruleList in _rules.Values)
+            if (_rulesDictionary.TryGetValue(key, out var currentRules))
             {
-                foreach (var rule in ruleList)
-                {
-                    yield return rule;
-                }
+                currentRules.Add(newRule);
+                return currentRules.Remove(oldRule);
             }
+            return false;
+        }
+
+        /// <summary>
+        /// Removes a collection of rules.
+        /// </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)
+        {
+            return _rulesDictionary.Remove(key);
+        }
+
+        /// <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)
+        {
+            if (_rulesDictionary.TryGetValue(key, out IList<ValidationRule> validationRules))
+            {
+                return validationRules.Remove(rule);
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Removes the first rule  that matches the provided rule from the list of rules.
+        /// </summary>
+        /// <param name="rule">The rule to be removed.</param>
+        /// <returns>true if the rule is successfully removed; otherwise, false.</returns>
+        public bool Remove(ValidationRule rule)
+        {
+            return _rulesDictionary.Values.FirstOrDefault(x => x.Remove(rule)) is not null;
+        }
+
+        /// <summary>
+        /// Clears all rules in this rule set.
+        /// </summary>
+        public void Clear()
+        {
+            _rulesDictionary.Clear();
+        }
+
+        /// <summary>
+        /// Determines whether the rule set contains an element with the specified key.
+        /// </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)
+        {
+            return _rulesDictionary.ContainsKey(key);
+        }
+
+        /// <summary>
+        /// Determines whether the provided rule is contained in the specified key in the rule set.
+        /// </summary>
+        /// <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)
+        {
+            return _rulesDictionary.TryGetValue(key, out IList<ValidationRule> validationRules) && validationRules.Contains(rule);
+        }
+
+        /// <summary>
+        /// Gets the rules associated with the specified key.
+        /// </summary>
+        /// <param name="key">The key whose rules to get.</param>
+        /// <param name="rules">When this method returns, the rules associated with the specified key, if the
+        ///  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)
+        {
+            return _rulesDictionary.TryGetValue(key, out rules);
         }
 
         /// <summary>
         /// Get the enumerator.
         /// </summary>
         /// <returns>The enumerator.</returns>
-        IEnumerator IEnumerable.GetEnumerator()
+        public IEnumerator<ValidationRule> GetEnumerator()
         {
-            return this.GetEnumerator();
+            foreach (var ruleList in _rulesDictionary.Values)
+            {
+                foreach (var rule in ruleList)
+                {
+                    yield return rule;
+                }
+            }
         }
 
         private static ValidationRuleSet BuildDefaultRuleSet()
@@ -179,7 +301,7 @@ private static ValidationRuleSet BuildDefaultRuleSet()
                 ValidationRule rule = propertyValue as ValidationRule;
                 if (rule != null)
                 {
-                    ruleSet.Add(rule);
+                    ruleSet.Add(rule.ElementType.Name, rule);
                 }
             }
 
diff --git a/test/Microsoft.OpenApi.Tests/PublicApi/PublicApi.approved.txt b/test/Microsoft.OpenApi.Tests/PublicApi/PublicApi.approved.txt
index 2948950f7..c12a59de5 100755
--- a/test/Microsoft.OpenApi.Tests/PublicApi/PublicApi.approved.txt
+++ b/test/Microsoft.OpenApi.Tests/PublicApi/PublicApi.approved.txt
@@ -1222,15 +1222,27 @@ namespace Microsoft.OpenApi.Validations
     {
         protected ValidationRule() { }
     }
-    public sealed class ValidationRuleSet : System.Collections.Generic.IEnumerable<Microsoft.OpenApi.Validations.ValidationRule>, System.Collections.IEnumerable
+    public sealed class ValidationRuleSet
     {
         public ValidationRuleSet() { }
         public ValidationRuleSet(Microsoft.OpenApi.Validations.ValidationRuleSet ruleSet) { }
-        public ValidationRuleSet(System.Collections.Generic.IEnumerable<Microsoft.OpenApi.Validations.ValidationRule> rules) { }
-        public System.Collections.Generic.IEnumerable<Microsoft.OpenApi.Validations.ValidationRule> Rules { get; }
-        public void Add(Microsoft.OpenApi.Validations.ValidationRule rule) { }
-        public System.Collections.Generic.IList<Microsoft.OpenApi.Validations.ValidationRule> FindRules(System.Type type) { }
+        public ValidationRuleSet(System.Collections.Generic.IDictionary<string, System.Collections.Generic.IList<Microsoft.OpenApi.Validations.ValidationRule>> rules) { }
+        public int Count { get; }
+        public System.Collections.Generic.ICollection<string> Keys { get; }
+        public System.Collections.Generic.IList<Microsoft.OpenApi.Validations.ValidationRule> Rules { get; }
+        public void Add(string key, Microsoft.OpenApi.Validations.ValidationRule rule) { }
+        public void Add(string key, System.Collections.Generic.IList<Microsoft.OpenApi.Validations.ValidationRule> rules) { }
+        public void Clear() { }
+        public bool Contains(string key, Microsoft.OpenApi.Validations.ValidationRule rule) { }
+        public bool ContainsKey(string key) { }
+        public System.Collections.Generic.IList<Microsoft.OpenApi.Validations.ValidationRule> FindRules(string key) { }
         public System.Collections.Generic.IEnumerator<Microsoft.OpenApi.Validations.ValidationRule> GetEnumerator() { }
+        public bool Remove(Microsoft.OpenApi.Validations.ValidationRule rule) { }
+        public bool Remove(string key) { }
+        public bool Remove(string key, Microsoft.OpenApi.Validations.ValidationRule rule) { }
+        public bool TryGetValue(string key, out System.Collections.Generic.IList<Microsoft.OpenApi.Validations.ValidationRule> rules) { }
+        public bool Update(string key, Microsoft.OpenApi.Validations.ValidationRule newRule, Microsoft.OpenApi.Validations.ValidationRule oldRule) { }
+        public static void AddValidationRules(Microsoft.OpenApi.Validations.ValidationRuleSet ruleSet, System.Collections.Generic.IDictionary<string, System.Collections.Generic.IList<Microsoft.OpenApi.Validations.ValidationRule>> rules) { }
         public static Microsoft.OpenApi.Validations.ValidationRuleSet GetDefaultRuleSet() { }
         public static Microsoft.OpenApi.Validations.ValidationRuleSet GetEmptyRuleSet() { }
     }
diff --git a/test/Microsoft.OpenApi.Tests/Services/OpenApiValidatorTests.cs b/test/Microsoft.OpenApi.Tests/Services/OpenApiValidatorTests.cs
index ef036a56b..85420890c 100644
--- a/test/Microsoft.OpenApi.Tests/Services/OpenApiValidatorTests.cs
+++ b/test/Microsoft.OpenApi.Tests/Services/OpenApiValidatorTests.cs
@@ -108,7 +108,7 @@ public void ValidateCustomExtension()
         {
             var ruleset = ValidationRuleSet.GetDefaultRuleSet();
 
-            ruleset.Add(
+            ruleset.Add(typeof(OpenApiAny).Name, 
              new ValidationRule<OpenApiAny>(
                  (context, item) =>
                  {
diff --git a/test/Microsoft.OpenApi.Tests/Validations/OpenApiReferenceValidationTests.cs b/test/Microsoft.OpenApi.Tests/Validations/OpenApiReferenceValidationTests.cs
index 3ed365c8d..43576475d 100644
--- a/test/Microsoft.OpenApi.Tests/Validations/OpenApiReferenceValidationTests.cs
+++ b/test/Microsoft.OpenApi.Tests/Validations/OpenApiReferenceValidationTests.cs
@@ -1,11 +1,8 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT license. 
 
-using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 using Microsoft.OpenApi.Extensions;
 using Microsoft.OpenApi.Interfaces;
 using Microsoft.OpenApi.Models;
@@ -67,7 +64,14 @@ public void ReferencedSchemaShouldOnlyBeValidatedOnce()
             };
 
             // Act
-            var errors = document.Validate(new ValidationRuleSet() { new AlwaysFailRule<OpenApiSchema>() });
+            var rules = new Dictionary<string, IList<ValidationRule>>()
+            {
+                { typeof(OpenApiSchema).Name,
+                    new List<ValidationRule>() { new AlwaysFailRule<OpenApiSchema>() }
+                }
+            };
+
+            var errors = document.Validate(new ValidationRuleSet(rules));
 
 
             // Assert
@@ -97,8 +101,15 @@ public void UnresolvedReferenceSchemaShouldNotBeValidated()
                 }
             };
 
-            // Act
-            var errors = document.Validate(new ValidationRuleSet() { new AlwaysFailRule<OpenApiSchema>() });
+            // Act            
+            var rules = new Dictionary<string, IList<ValidationRule>>()
+            {
+                { typeof(AlwaysFailRule<OpenApiSchema>).Name,
+                    new List<ValidationRule>() { new AlwaysFailRule<OpenApiSchema>() }
+                }
+            };
+
+            var errors = document.Validate(new ValidationRuleSet(rules));
 
             // Assert
             Assert.True(errors.Count() == 0);
@@ -147,7 +158,14 @@ public void UnresolvedSchemaReferencedShouldNotBeValidated()
             };
 
             // Act
-            var errors = document.Validate(new ValidationRuleSet() { new AlwaysFailRule<OpenApiSchema>() });
+            var rules = new Dictionary<string, IList<ValidationRule>>()
+            {
+                { typeof(AlwaysFailRule<OpenApiSchema>).Name,
+                    new List<ValidationRule>() { new AlwaysFailRule<OpenApiSchema>() }
+                }
+            };
+
+            var errors = document.Validate(new ValidationRuleSet(rules));
 
             // Assert
             Assert.True(errors.Count() == 0);
diff --git a/test/Microsoft.OpenApi.Tests/Validations/ValidationRuleSetTests.cs b/test/Microsoft.OpenApi.Tests/Validations/ValidationRuleSetTests.cs
index 5124375ac..7685f80ca 100644
--- a/test/Microsoft.OpenApi.Tests/Validations/ValidationRuleSetTests.cs
+++ b/test/Microsoft.OpenApi.Tests/Validations/ValidationRuleSetTests.cs
@@ -1,50 +1,191 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT license.
 
+using System.Collections.Generic;
 using System.Linq;
+using Microsoft.OpenApi.Models;
 using Xunit;
-using Xunit.Abstractions;
 
 namespace Microsoft.OpenApi.Validations.Tests
 {
     public class ValidationRuleSetTests
     {
-        private readonly ITestOutputHelper _output;
+        private readonly ValidationRule  _contactValidationRule = new ValidationRule<OpenApiContact>(
+                (context, item) => { });
 
-        public ValidationRuleSetTests(ITestOutputHelper output)
+        private readonly ValidationRule _headerValidationRule = new ValidationRule<OpenApiHeader>(
+            (context, item) => { });
+
+        private readonly ValidationRule _parameterValidationRule = new ValidationRule<OpenApiParameter>(
+            (context, item) => { });
+
+        private readonly IDictionary<string, IList<ValidationRule>> _rulesDictionary; 
+
+        public ValidationRuleSetTests()
+        {
+            _rulesDictionary = new Dictionary<string, IList<ValidationRule>>()
+            {
+                {"contact", new List<ValidationRule> { _contactValidationRule } },
+                {"header", new List<ValidationRule> { _headerValidationRule } },
+                {"parameter", new List<ValidationRule> { _parameterValidationRule } }
+            };
+        }
+
+        [Fact]
+        public void RuleSetConstructorsReturnsTheCorrectRules()
         {
-            _output = output;
+            // Arrange & Act
+            var ruleSet_1 = ValidationRuleSet.GetDefaultRuleSet();
+            var ruleSet_2 = new ValidationRuleSet(ValidationRuleSet.GetDefaultRuleSet());
+            var ruleSet_3 = new ValidationRuleSet(_rulesDictionary);
+            var ruleSet_4 = new ValidationRuleSet();
+
+            // Assert
+            Assert.NotNull(ruleSet_1?.Rules); 
+            Assert.NotNull(ruleSet_2?.Rules);
+            Assert.NotNull(ruleSet_3?.Rules);
+            Assert.NotNull(ruleSet_4);
+
+            Assert.NotEmpty(ruleSet_1.Rules);
+            Assert.NotEmpty(ruleSet_2.Rules);
+            Assert.NotEmpty(ruleSet_3.Rules);
+            Assert.Empty(ruleSet_4.Rules);
+
+            // Update the number if you add new default rule(s).
+            Assert.Equal(22, ruleSet_1.Rules.Count);
+            Assert.Equal(22, ruleSet_2.Rules.Count);
+            Assert.Equal(3, ruleSet_3.Rules.Count);
         }
 
         [Fact]
-        public void DefaultRuleSetReturnsTheCorrectRules()
+        public void RemoveValidatioRuleGivenTheValidationRuleWorks()
         {
             // Arrange
-            var ruleSet = new ValidationRuleSet();
+            var ruleSet = new ValidationRuleSet(_rulesDictionary);
+            var responseValidationRule = new ValidationRule<OpenApiResponse>((context, item) => { });
+
+            // Act and Assert
+            Assert.True(ruleSet.Remove(_contactValidationRule));
+            Assert.False(ruleSet.Rules.Contains(_contactValidationRule));
+            Assert.False(ruleSet.Remove(_contactValidationRule)); // rule already removed
+        }
+
+        [Fact]
+        public void RemoveValidationRuleGivenTheKeyAndValidationRuleWorks()
+        {
+            // Arrange
+            var ruleSet = new ValidationRuleSet(_rulesDictionary);
 
             // Act
+            ruleSet.Remove("contact", _contactValidationRule);
+            ruleSet.Remove("parameter", _headerValidationRule); // validation rule not in parameter key; shouldn't remove
+            ruleSet.Remove("foo", _parameterValidationRule); // key does not exist; shouldn't remove
+
             var rules = ruleSet.Rules;
 
             // Assert
-            Assert.NotNull(rules);
-            Assert.Empty(rules);
+            Assert.False(rules.Contains(_contactValidationRule));
+            Assert.True(rules.Contains(_headerValidationRule));
+            Assert.True(rules.Contains(_parameterValidationRule));
         }
 
         [Fact]
-        public void DefaultRuleSetPropertyReturnsTheCorrectRules()
+        public void RemoveRulesGivenAKeyWorks()
         {
-            // Arrange & Act
-            var ruleSet = ValidationRuleSet.GetDefaultRuleSet();
-            Assert.NotNull(ruleSet); // guard
+            // Arrange
+            var ruleSet = new ValidationRuleSet(_rulesDictionary);
+            var responseValidationRule = new ValidationRule<OpenApiResponse>((context, item) => { });
+            ruleSet.Add("response", new List<ValidationRule> { responseValidationRule });
+            Assert.True(ruleSet.ContainsKey("response"));
+            Assert.True(ruleSet.Rules.Contains(responseValidationRule)); // guard
 
-            var rules = ruleSet.Rules;
+            // Act
+            ruleSet.Remove("response");
 
             // Assert
-            Assert.NotNull(rules);
-            Assert.NotEmpty(rules);
+            Assert.False(ruleSet.ContainsKey("response"));
+        }
 
-            // Update the number if you add new default rule(s).
-            Assert.Equal(22, rules.Count());
+        [Fact]
+        public void AddNewValidationRuleWorks()
+        {
+            // Arrange
+            var ruleSet = new ValidationRuleSet(_rulesDictionary);
+            var responseValidationRule = new ValidationRule<OpenApiResponse>((context, item) => { });
+            var tagValidationRule = new ValidationRule<OpenApiTag>((context, item) => { });
+            var pathsValidationRule = new ValidationRule<OpenApiPaths>((context, item) => { });
+
+            // Act
+            ruleSet.Add("response", new List<ValidationRule> { responseValidationRule });
+            ruleSet.Add("tag", new List<ValidationRule> { tagValidationRule });
+            var rulesDictionary = new Dictionary<string, IList<ValidationRule>>()
+            {
+                {"paths", new List<ValidationRule> { pathsValidationRule } }
+            };
+
+            ValidationRuleSet.AddValidationRules(ruleSet, rulesDictionary);
+            
+            // Assert
+            Assert.True(ruleSet.ContainsKey("response"));
+            Assert.True(ruleSet.ContainsKey("tag"));
+            Assert.True(ruleSet.ContainsKey("paths"));
+            Assert.True(ruleSet.Rules.Contains(responseValidationRule));
+            Assert.True(ruleSet.Rules.Contains(tagValidationRule));
+            Assert.True(ruleSet.Rules.Contains(pathsValidationRule));
+        }
+
+        [Fact]
+        public void UpdateValidationRuleWorks()
+        {
+            // Arrange
+            var ruleSet = new ValidationRuleSet(_rulesDictionary);
+            var responseValidationRule = new ValidationRule<OpenApiResponse>((context, item) => { });
+            ruleSet.Add("response", new List<ValidationRule> { responseValidationRule });
+
+            // Act
+            var pathsValidationRule = new ValidationRule<OpenApiPaths>((context, item) => { });
+            ruleSet.Update("response", pathsValidationRule, responseValidationRule);
+
+            // Assert
+            Assert.True(ruleSet.Contains("response", pathsValidationRule));
+            Assert.False(ruleSet.Contains("response", responseValidationRule));
+        }
+
+        [Fact]
+        public void TryGetValueWorks()
+        {
+            // Arrange
+            var ruleSet = new ValidationRuleSet(_rulesDictionary);
+
+            // Act
+            ruleSet.TryGetValue("contact", out var validationRules); 
+            
+            // Assert
+            Assert.True(validationRules.Any());
+            Assert.True(validationRules.Contains(_contactValidationRule));
+        }
+
+        [Fact]
+        public void ClearAllRulesWorks()
+        {
+            // Arrange
+            var ruleSet = new ValidationRuleSet();
+            var tagValidationRule = new ValidationRule<OpenApiTag>((context, item) => { });
+            var pathsValidationRule = new ValidationRule<OpenApiPaths>((context, item) => { });
+            var rulesDictionary = new Dictionary<string, IList<ValidationRule>>()
+            {
+                {"paths", new List<ValidationRule> { pathsValidationRule } },
+                {"tag", new List<ValidationRule> { tagValidationRule } }
+            };
+
+            ValidationRuleSet.AddValidationRules(ruleSet, rulesDictionary);
+            Assert.NotEmpty(ruleSet.Rules);
+
+            // Act
+            ruleSet.Clear();
+
+            // Assert
+            Assert.Empty(ruleSet.Rules);
         }
     }
 }