Update the validation process to be recursive

Author: MaggieKimani1

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

@@ -1,7 +1,6 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT license. 
 
-using Microsoft.OpenApi.Any;
 using Microsoft.OpenApi.Models;
 using Microsoft.OpenApi.Properties;
 using System.Collections.Generic;
@@ -11,7 +10,6 @@ namespace Microsoft.OpenApi.Validations.Rules
     /// <summary>
     /// The validation rules for <see cref="OpenApiSchema"/>.
     /// </summary>
-    
     [OpenApiRule]
     public static class OpenApiSchemaRules
     {
@@ -70,50 +68,77 @@ public static class OpenApiSchemaRules
 
                     if (schema.Reference != null && schema.Discriminator != null)
                     {
-                        if (!schema.Required.Contains(schema.Discriminator?.PropertyName))
+                        var discriminator = schema.Discriminator?.PropertyName;
+                        var schemaReferenceId = schema.Reference.Id;
+
+                        if (!ValidateChildSchemaAgainstDiscriminator(schema, discriminator, schemaReferenceId, context))
                         {
-                            // check schema.OneOf, schema.AnyOf or schema.AllOf
-                            if(schema.OneOf.Count != 0)
-                            {
-                                ValidateDiscriminatorAgainstChildSchema(schema.OneOf, schema, context);                                
-                            }
-                            else if (schema.AnyOf.Count != 0)
-                            {
-                                ValidateDiscriminatorAgainstChildSchema(schema.AnyOf, schema, context);
-                            }
-                            else if (schema.AllOf.Count != 0)
-                            {
-                                ValidateDiscriminatorAgainstChildSchema(schema.AllOf, schema, context);
-                            }
-                            else
-                            {
-                                context.CreateError(nameof(ValidateSchemaDiscriminator),
-                                            string.Format(SRResource.Validation_SchemaRequiredFieldListMustContainThePropertySpecifiedInTheDiscriminator,
-                                                                            schema.Reference.Id, schema.Discriminator.PropertyName));
-                            }
+                            context.CreateError(nameof(ValidateSchemaDiscriminator),
+                            string.Format(SRResource.Validation_SchemaRequiredFieldListMustContainThePropertySpecifiedInTheDiscriminator,
+                                schemaReferenceId, discriminator));
                         }
                     }
-                    
+
                     context.Exit();
                 });
 
         /// <summary>
         /// Validates the property name in the discriminator against the ones present in the children schema
         /// </summary>
-        /// <param name="childSchema">The derived schema.</param>
         /// <param name="schema">The parent schema.</param>
+        /// <param name="discriminator">Adds support for polymorphism. The discriminator is an object name that is used to differentiate
+        /// between other schemas which may satisfy the payload description.</param>
+        /// <param name="schemaReferenceId"></param>
         /// <param name="context">A validation context.</param>
-        public static void ValidateDiscriminatorAgainstChildSchema(IList<OpenApiSchema> childSchema, OpenApiSchema schema, IValidationContext context)
+        public static bool ValidateChildSchemaAgainstDiscriminator(OpenApiSchema schema, string discriminator, string schemaReferenceId, IValidationContext context)
         {
-            foreach (var schemaItem in childSchema)
+            bool containsDiscriminator = false;
+
+            if (!schema.Required.Contains(discriminator))
             {
-                if (!schemaItem.Properties.Keys.Contains(schema.Discriminator?.PropertyName))
+                // recursively check nested schema.OneOf, schema.AnyOf or schema.AllOf and their required fields for the discriminator
+                if (schema.OneOf.Count != 0)
+                {
+                    return TraverseSchemaElements(discriminator, schema.OneOf, schemaReferenceId, context, containsDiscriminator);
+                }
+                if (schema.AnyOf.Count != 0)
                 {
-                    context.CreateError(nameof(ValidateSchemaDiscriminator),
-                                string.Format(SRResource.Validation_SchemaRequiredFieldListMustContainThePropertySpecifiedInTheDiscriminator,
-                                                                schema.Reference.Id, schema.Discriminator.PropertyName));
+                    return TraverseSchemaElements(discriminator, schema.AnyOf, schemaReferenceId, context, containsDiscriminator);
                 }
-            }            
+                if (schema.AllOf.Count != 0)
+                {
+                    return TraverseSchemaElements(discriminator, schema.AllOf, schemaReferenceId, context, containsDiscriminator);
+                }
+            }
+
+            return containsDiscriminator;
+        }
+
+        /// <summary>
+        /// Traverses the schema elements and checks whether the schema contains the discriminator.
+        /// </summary>
+        /// <param name="discriminator">Adds support for polymorphism. The discriminator is an object name that is used to differentiate
+        /// between other schemas which may satisfy the payload description.</param>
+        /// <param name="childSchema">The child schema.</param>
+        /// <param name="schemaReferenceId"> The schema reference Id.</param>
+        /// <param name="context"> A validation context.</param>
+        /// <param name="containsDiscriminator">Tracks whether the discriminator is present.</param>
+        /// <returns></returns>
+        public static bool TraverseSchemaElements(string discriminator, IList<OpenApiSchema> childSchema, string schemaReferenceId, IValidationContext context, bool containsDiscriminator)
+        {
+            foreach (var childItem in childSchema)
+            {
+                if (!childItem.Properties.ContainsKey(discriminator) && !childItem.Required.Contains(discriminator))
+                {
+                    return ValidateChildSchemaAgainstDiscriminator(childItem, discriminator, schemaReferenceId, context);
+                }
+                else
+                {
+                    return containsDiscriminator = true;
+                }
+            }
+
+            return containsDiscriminator;
         }
     }
 }